BZOJ2118 墨墨的等式

Description

传送门

大致就是给定等式(a_{1}x_{1} + a_{2}x_{2} + a_{3}x_{3} dots + a_{n}x_{n}= B), 现在给定({a}),(B)的取值范围([B_{Min}, B_{Max}]), 求B的取值范围内有多少个B使({x})有非负整数解.

Solution

先进行一个简单的转化, 直接求([0, l - 1])，([0,r]) 的解然后减去.就只要考虑怎么求([0, a])的答案.

我们进行一个简单的转化, 现在给定n个物品, 每个物品有无数个,求能表示出的价值的个数.

考虑一个数Z作为价值, 如果(l)能被Z表示为(l = kZ + D), 那么((l + z))也能被表示为((k + 1)Z + D)

可以简单的发现(D leq Z) 于是我们考虑答案按照模(k)的剩余系分类, 然后最后计算剩余系的总和.

设(a_i)为$a_i = Min{Q}, Q_modk = i $且能被构造.那么答案就很好计算.

我们考虑(k)怎么取值.显然,k取(min {a_i})最好, 因为它的剩余系大小最小.

那么对于任意一个i和a[j], 我们用最短路求解, 从(i)向((a_j + i) \% k),连接一条长度为(a_{j})的边.

然后跑一遍最短路即可

Codes

#include<bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for(int i = (a), i##_end_ = (b); i <= i##_end_; ++i)
#define drep(i, a, b) for(int i = (a), i##_end_ = (b); i >= i##_end_; --i)
#define clar(a, b) memset((a), (b), sizeof(a))
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define Debug(s) debug("The massage in line %d, Function %s: %s
", __LINE__, __FUNCTION__, s)
typedef long long LL;
typedef long double LD;
const int BUF_SIZE = (int)1e6 + 10;
struct fastIO {
    char buf[BUF_SIZE], buf1[BUF_SIZE];
    int cur, cur1;
    FILE *in, *out;
    fastIO() {
        cur = BUF_SIZE, in = stdin, out = stdout;
		cur1 = 0;
    }
    inline char getchar() {
        if(cur == BUF_SIZE) fread(buf, BUF_SIZE, 1, in), cur = 0;
        return *(buf + (cur++));
    }
    inline void putchar(char ch) {
        *(buf1 + (cur1++)) = ch;
        if (cur1 == BUF_SIZE) fwrite(buf1, BUF_SIZE, 1, out), cur1 = 0;
    }
    inline void flush() {
        if (cur1 > 0) fwrite(buf1, cur1, 1, out);
        cur1 = 0;
    }
}IO;
LL read() {
	char ch = IO.getchar();
	LL x = 0, flag = 1;
	for(;!isdigit(ch); ch = IO.getchar()) if(ch == '-') flag *= -1;
	for(;isdigit(ch); ch = IO.getchar()) x = x * 10 + ch - 48;
	return x * flag;
}
void write(LL x) {
	if(x < 0) x = -x, IO.putchar('-');
	if(x >= 10) write(x / 10);
	IO.putchar(x % 10 + 48);
}

#define Maxn 100
#define Maxc 1000009
LL n, l, r, a[Maxn];
struct edge {
	int to, nxt, w;
}g[Maxc * 20];
int head[Maxc], e;
LL Min = LLONG_MAX;
void add(int u, int v, int w) {
	g[++e] = (edge){v, head[u], w}, head[u] = e;
}
namespace SSSP {
	struct node {
		LL id, d;
		int operator < (const node b) const {
			return d > b.d;
		}
	};
	LL dis[Maxc]; int vis[Maxc];
	priority_queue <node> que;
	void Init_Graph() {
		clar(head, -1);
		rep(i, 0, Min - 1)
			rep(j, 1, n) add(i, (1ll * i + a[j]) % Min, a[j]);
	}
	void Dijkstra() {
		clar(dis, 0x3f);
		que.push((node){0, 0}); dis[0] = 0;
		while(!que.empty()) {
			node u = que.top(); que.pop();
			if(vis[u.id]) continue;
			vis[u.id] = 1;
			for(int i = *(head + u.id); ~i; i = g[i].nxt) {
				int v = g[i].to; 
				if(!vis[v] && dis[v] > dis[u.id] + g[i].w) {
					dis[v] = dis[u.id] + g[i].w;
					que.push({v, dis[v]});
				}
			}
		}
	}
}
LL solve(LL a) {
	LL ret = 0;	
	rep(i, 0, Min - 1)
		if(SSSP :: dis[i] <= a) 
			ret += (a - SSSP :: dis[i]) / Min + 1;
	return ret;
}
int main() {
#ifdef Qrsikno
	freopen("BZOJ2118.in", "r", stdin);
	freopen("BZOJ2118.out", "w", stdout);
#endif
	n = read(), l = read(), r = read();
	rep(i, 1, n) a[i] = read(), Min = min(a[i], Min);
	SSSP :: Init_Graph();
	SSSP :: Dijkstra();
	write(solve(r) - solve(l - 1));	
	IO.flush();
	return 0;
}

启发

对于一种求最小化(a_i)的值的问题,并且(a_i)可以由其他项目简单的动态的求出.可以考虑最短路求解.这事实上提供了一种建模的好方法.

如果(a_i) 的取值范围过于大, 可以考虑按模数分类后计算, 统计答案时求和