text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
inline int in() {
char c = getchar();
int neg = 1, x = 0;
while (!isdigit(c)) (c == '-') ? neg = -1, c = getchar() : c = getchar();
while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return neg * x;
}
const int MAX = 1e4 + 5;
int N, K, L, ptr, lgt, turn[21], dp[1 << 20], sp[MAX], step[21][21], x[105];
bool light[MAX];
queue<int> q;
inline void bfs(int *d, int st) {
memset(sp, 63, sizeof(sp));
sp[turn[st]] = 0;
q.push(turn[st]);
while (!q.empty()) {
int t = q.front();
q.pop();
for (register int i = 0; i < L; i++) {
if (t + x[i] <= N + 1 && sp[t + x[i]] > 1e8)
sp[t + x[i]] = sp[t] + 1, q.push(t + x[i]);
if (t - x[i] >= 1 && sp[t - x[i]] > 1e8)
sp[t - x[i]] = sp[t] + 1, q.push(t - x[i]);
}
}
for (int i = st + 1; i < ptr; i++) d[i] = sp[turn[i]];
}
inline int dfs(int S) {
if (~dp[S]) return dp[S];
dp[S] = 1e9 + 7;
for (register int i = 0; i < ptr; i++)
if (S >> i & 1) {
for (int j = i + 1; j < ptr; j++)
if (S >> j & 1)
dp[S] = min(dp[S], dfs(S ^ (1 << i) ^ (1 << j)) + step[i][j]);
break;
}
return dp[S];
}
inline void pre_work() {
for (register int i = 1; i <= N + 1; i++)
if (light[i] != light[i - 1]) turn[ptr++] = i;
for (register int i = 0; i < ptr; i++) bfs(step[i], i);
}
int main() {
N = in(), K = in(), L = in();
for (register int i = 0; i < K; i++) lgt = in(), light[lgt] = true;
for (register int i = 0; i < L; i++) x[i] = in();
pre_work();
memset(dp, -1, sizeof(dp));
dp[0] = 0;
if (dfs((1 << ptr) - 1) > 1e8)
puts("-1");
else
printf("%d\n", dp[(1 << ptr) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10010, MAXK = 25, MAXO = 110, oo = 100000000, MAXZ = 1 << 20;
int C[MAXN], tmp, B[MAXN], A[MAXK], oper[MAXO], D[MAXN];
int g[MAXK][MAXN], opt[MAXZ], visit[MAXK][MAXN], onum;
int N, K, L, tot, head, tail, z, ox[MAXK * MAXK], oy[MAXK * MAXK];
pair<int, int> q[MAXN * MAXK];
int qq[MAXZ], vis[MAXZ], TIME, isok[MAXZ];
inline void addg(int dist, int x, int y) {
if (g[x][y] > dist + 1 || visit[x][y] != TIME) {
visit[x][y] = TIME;
g[x][y] = dist + 1;
q[++tail] = make_pair(x, y);
}
}
void calc() {
head = 0;
tail = 0;
for (int i = 1; i <= tot; ++i) {
g[i][A[i]] = 0;
visit[i][A[i]] = TIME;
}
for (int i = 1; i <= L; ++i)
for (int j = 1; j <= tot; ++j) {
if (A[j] + oper[i] <= N + 1) {
g[j][A[j] + oper[i]] = 1;
visit[j][A[j] + oper[i]] = TIME;
q[++tail] = make_pair(j, A[j] + oper[i]);
}
if (A[j] - oper[i] > 0) {
g[j][A[j] - oper[i]] = 1;
visit[j][A[j] - oper[i]] = TIME;
q[++tail] = make_pair(j, A[j] - oper[i]);
}
}
while (head != tail) {
++head;
int x = q[head].first, y = q[head].second;
for (int i = 1; i <= L; ++i) {
if (y + oper[i] <= N + 1) addg(g[x][y], x, y + oper[i]);
if (y - oper[i] > 0) addg(g[x][y], x, y - oper[i]);
if (A[x] + oper[i] <= N + 1 && D[A[x] + oper[i]])
addg(g[x][y], D[A[x] + oper[i]], y);
if (A[x] - oper[i] > 0 && D[A[x] - oper[i]])
addg(g[x][y], D[A[x] - oper[i]], y);
}
}
onum = 0;
for (int i = 1; i <= tot; ++i)
for (int j = i + 1; j <= tot; ++j) {
tmp = oo;
if (visit[i][A[j]] == TIME && g[i][A[j]] < tmp) tmp = g[i][A[j]];
if (visit[j][A[i]] == TIME && g[j][A[i]] < tmp) tmp = g[j][A[i]];
if (tmp < oo) {
++onum;
ox[onum] = (1 << (i - 1)) | (1 << (j - 1));
oy[onum] = tmp;
}
}
}
void spfa() {
head = 0;
tail = 1;
qq[1] = 0;
while (head != tail) {
head = (head + 1) & (MAXZ - 1);
int x = qq[head];
vis[x] = 0;
for (int i = 1; i <= onum; ++i)
if (opt[x ^ ox[i]] > opt[x] + oy[i] || isok[x ^ ox[i]] != TIME) {
isok[x ^ ox[i]] = TIME;
opt[x ^ ox[i]] = opt[x] + oy[i];
if (!vis[x ^ ox[i]]) {
vis[x ^ ox[i]] = 1;
tail = (tail + 1) & (MAXZ - 1);
qq[tail] = x ^ ox[i];
}
}
}
}
void doit() {
scanf("%d%d%d", &N, &K, &L);
for (int i = 0; i <= N + 1; ++i) C[i] = D[i] = 0;
for (int i = 1; i <= K; ++i) {
scanf("%d", &tmp);
C[tmp] = 1;
}
tot = 0;
for (int i = 1; i <= N + 1; ++i)
if (C[i] != C[i - 1]) {
A[++tot] = i;
D[i] = tot;
}
for (int i = 1; i <= L; ++i) scanf("%d", &oper[i]);
calc();
z = (1 << tot) - 1;
opt[0] = 0;
isok[0] = TIME;
spfa();
if (opt[z] < oo && isok[z] == TIME)
printf("%d\n", opt[z]);
else
printf("-1\n");
}
int main(void) {
int TestCase;
{
++TIME;
doit();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 29;
int n, m, k, cnt, pos[10010], a[10010], b[10010], f[1 << 25], dis[10010],
g[30][30];
bool vis[10010];
queue<int> q;
inline void bfs(int x, int id) {
memset(dis, 0x3f3f3f3f, sizeof(dis));
memset(vis, 0, sizeof(vis));
q.push(x);
vis[x] = 1;
dis[x] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 1; i <= m; i++) {
int v = a[i];
if (u + v <= n && !vis[u + v]) {
dis[u + v] = dis[u] + 1;
vis[u + v] = 1;
q.push(u + v);
}
if (u - v >= 1 && !vis[u - v]) {
dis[u - v] = dis[u] + 1;
vis[u - v] = 1;
q.push(u - v);
}
}
}
for (int i = 1; i <= cnt; i++)
if (vis[b[i]])
g[id][i] = dis[b[i]];
else
g[id][i] = inf;
}
int main() {
scanf("%d%d%d", &n, &k, &m);
for (int i = 1, x; i <= k; i++) scanf("%d", &x), pos[x] = 1;
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
n++;
for (int i = n; i >= 1; i--) pos[i] ^= pos[i - 1];
for (int i = 1; i <= n; i++)
if (pos[i]) {
pos[i] = ++cnt;
b[cnt] = i;
}
for (int i = 1; i <= n; i++)
if (pos[i]) bfs(i, pos[i]);
for (int i = 1; i < (1 << cnt); i++) f[i] = inf;
for (int i = 0, k; i < (1 << cnt); i++) {
for (int j = 1; j <= cnt; j++)
if ((1 << j - 1) & i) {
k = j;
break;
}
for (int j = 1; j <= cnt; j++)
if ((1 << j - 1) & i)
f[i] = min(f[i], f[i ^ (1 << k - 1) ^ (1 << j - 1)] + g[k][j]);
}
printf("%d", f[(1 << cnt) - 1] == inf ? -1 : f[(1 << cnt) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10005;
int can[N], data[N];
vector<int> msk;
int Road[1100], cost[1100000];
long long dp[1100000];
int n, m, k;
int dis[N];
void bfs(int s) {
memset(dis, 0x3f, sizeof(dis));
dis[s] = 0;
queue<int> Q;
Q.push(s);
while (!Q.empty()) {
int f = Q.front();
Q.pop();
for (int i = (0); i < (k); ++i) {
if (f - Road[i] >= 1) {
int nxt = f - Road[i];
if (dis[nxt] > dis[f] + 1) {
dis[nxt] = dis[f] + 1;
Q.push(nxt);
}
}
if (f + Road[i] <= n) {
int nxt = f + Road[i];
if (dis[nxt] > dis[f] + 1) {
dis[nxt] = dis[f] + 1;
Q.push(nxt);
}
}
}
}
}
int solve(int mask) {
int ans = 0;
while (mask) ans += mask % 2, mask >>= 1;
return ans % 2 == 0;
}
int main() {
memset(dp, 0x3f, sizeof(dp));
scanf("%d%d%d", &n, &m, &k);
n++;
for (int i = (0); i < (m); ++i) {
int a;
scanf("%d", &a);
can[a] = 1;
}
for (int i = (0); i < (k); ++i) scanf("%d", &Road[i]);
for (int i = (1); i < (n + 1); ++i) {
data[i] = can[i] ^ can[i - 1];
if (data[i]) msk.push_back(i);
}
for (int i = (0); i < ((int)msk.size()); ++i) {
bfs(msk[i]);
for (int j = (i + 1); j < ((int)msk.size()); ++j) {
cost[(1 << i) ^ (1 << j)] = dis[msk[j]];
}
}
dp[0] = 0;
for (int mask = (1); mask < (1 << (int)msk.size()); ++mask)
if (solve(mask)) {
vector<int> V;
for (int j = (0); j < ((int)msk.size()); ++j)
if (mask >> j & 1) V.push_back(j);
for (int j = (1); j < ((int)V.size()); ++j)
dp[mask] = min(dp[mask], dp[mask ^ (1 << V[0]) ^ (1 << V[j])] +
cost[(1 << V[0]) ^ (1 << V[j])]);
}
long long ans = dp[(1 << (int)msk.size()) - 1];
if (ans > 1e9)
puts("-1");
else
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt[11 << 1], dis[10010], vis[10010], p[10010], trs[11 << 1][11 << 1],
q[10010], a[10010], dp[1 << (11 << 1)], n, k, l;
struct Node {
int id, dis;
Node(int A = 0, int B = 0) {
id = A;
dis = B;
}
inline bool operator<(const Node &o) const { return dis < o.dis; }
};
priority_queue<Node> que;
queue<int> qq;
inline void dijk(int x) {
memset(vis, 0, sizeof vis);
memset(dis, 0x3f, sizeof dis);
dis[cnt[x]] = 0;
vis[cnt[x]] = 1;
qq.push(cnt[x]);
while (!qq.empty()) {
int now = qq.front();
qq.pop();
for (int i = 1; i <= l; ++i) {
if (now + a[i] <= n + 1 && !vis[now + a[i]]) {
dis[now + a[i]] = dis[now] + 1;
qq.push(now + a[i]);
vis[now + a[i]] = 1;
}
if (now - a[i] >= 1 && !vis[now - a[i]]) {
dis[now - a[i]] = dis[now] + 1;
qq.push(now - a[i]);
vis[now - a[i]] = 1;
}
}
}
for (int i = 1; i <= cnt[0]; ++i) {
trs[x][i] = dis[cnt[i]];
}
}
int main() {
scanf("%d%d%d", &n, &k, &l);
for (int i = 1, x; i <= k; ++i) {
scanf("%d", &x);
p[x] = 1;
}
for (int i = 1; i <= n + 1; ++i) {
q[i] = p[i] ^ p[i - 1];
if (q[i]) cnt[++cnt[0]] = i;
}
if (!cnt[0]) {
puts("0");
return 0;
}
for (int i = 1; i <= l; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= cnt[0]; ++i) dijk(i);
int all = (1 << cnt[0]);
memset(dp, 0x3f, sizeof dp);
dp[all - 1] = 0;
for (int sta = all - 1; sta >= 0; --sta) {
for (int i = 1; i <= cnt[0]; ++i) {
if (sta & (1 << i - 1)) {
for (int j = 1; j <= cnt[0]; ++j) {
if (i != j && (sta & (1 << j - 1))) {
int now = sta ^ (1 << i - 1) ^ (1 << j - 1);
dp[now] = min(dp[now], dp[sta] + trs[i][j]);
int x;
}
}
}
}
}
if (dp[0] == 0x3f3f3f3f)
puts("-1");
else
printf("%d\n", dp[0]);
return 0;
}
|
#include <bits/stdc++.h>
inline int read() {
int res = 0;
bool bo = 0;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
if (c == '-')
bo = 1;
else
res = c - 48;
while ((c = getchar()) >= '0' && c <= '9')
res = (res << 3) + (res << 1) + (c - 48);
return bo ? ~res + 1 : res;
}
template <class T>
inline T Min(const T &a, const T &b) {
return a < b ? a : b;
}
const int N = 1e4 + 5, E = 25, M = 205, C = (1 << 20) + 5, INF = 0x3f3f3f3f;
int n, k, m, arr[N], a[M], tot, w[E], g[E][E], dis[N], len, que[N], f[C], Cm,
dn[C];
void bfs(int S) {
memset(dis, INF, sizeof(dis));
dis[que[len = 1] = S] = 0;
for (int i = 1; i <= len; i++) {
int u = que[i];
for (int j = 1; j <= m; j++) {
int v = u + a[j];
if (v < 1 || v > n + 1 || dis[v] < INF) continue;
dis[que[++len] = v] = dis[u] + 1;
}
}
}
int main() {
n = read();
k = read();
m = read();
for (int i = 1; i <= k; i++) arr[read()] = 1;
for (int i = n; i; i--) arr[i] ^= arr[i - 1];
for (int i = 1; i <= m; i++) a[i] = read(), a[i + m] = -a[i];
m <<= 1;
for (int i = 1; i <= n; i++)
if (arr[i]) w[++tot] = i;
for (int i = 1; i <= tot; i++) {
bfs(w[i]);
for (int j = 1; j <= tot; j++) g[i][j] = dis[w[j]];
}
bfs(n + 1);
memset(f, INF, sizeof(f));
f[0] = 0;
Cm = 1 << tot;
for (int i = 1; i <= tot; i++) dn[1 << i - 1] = i;
for (int S = 1; S < Cm; S++) {
int id = dn[S & -S], T = S ^ (S & -S);
f[S] = Min(f[S], f[T] + dis[w[id]]);
for (int i = 1; i <= tot; i++)
if ((T >> i - 1) & 1) f[S] = Min(f[S], f[T ^ (1 << i - 1)] + g[id][i]);
}
printf("%d\n", f[Cm - 1] == INF ? -1 : f[Cm - 1]);
return 0;
}
|
#include <bits/stdc++.h>
inline int read() {
int data = 0, w = 1;
char ch = getchar();
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') w = -1, ch = getchar();
while (ch >= '0' && ch <= '9') data = data * 10 + (ch ^ 48), ch = getchar();
return data * w;
}
const int N(10010), M(21);
int T, n, K, L, a[N], tot, len[N], c[N], dis[M][N], vis[N], f[1 << M];
void bfs(int *dis, int S) {
std::queue<int> Q;
Q.push(S);
memset(vis, 0, sizeof vis);
memset(dis, 0x3f, (n + 1) << 2);
dis[S] = 0, vis[S] = 1;
while (!Q.empty()) {
int x = Q.front();
Q.pop();
for (int i = 1; i <= L && x + len[i] <= n; i++)
if (!vis[x + len[i]])
vis[x + len[i]] = 1, dis[x + len[i]] = dis[x] + 1, Q.push(x + len[i]);
for (int i = 1; i <= L && x - len[i] >= 0; i++)
if (!vis[x - len[i]])
vis[x - len[i]] = 1, dis[x - len[i]] = dis[x] + 1, Q.push(x - len[i]);
}
}
int main() {
n = read(), K = read(), L = read(), tot = 0;
for (int i = 0; i <= n; i++) a[i] = 0;
for (int i = 1; i <= K; i++) a[read()] = 1;
for (int i = 0; i <= n; i++)
if ((a[i] ^= a[i + 1])) c[++tot] = i;
for (int i = 1; i <= L; i++) len[i] = read();
std::sort(len + 1, len + L + 1);
for (int i = 1; i <= tot; i++) bfs(dis[i], c[i]);
memset(f, 0x3f, sizeof f), f[0] = 0;
for (int i = 1; i < (1 << tot); i++) {
if (__builtin_popcount(i) & 1) continue;
int t = __builtin_ctz(i);
for (int j = 0; j < tot; j++)
if ((1 << t) != (1 << j) && (i & (1 << j)))
f[i] =
std::min(f[i], f[i ^ (1 << t) ^ (1 << j)] + dis[t + 1][c[j + 1]]);
}
int ans = f[(1 << tot) - 1];
printf("%d\n", ans == 0x3f3f3f3f ? -1 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int x[200], a[200], n, k, l;
int vis[10005], dp[1 << (21)];
int val[25][25];
vector<int> V;
vector<pair<int, int> > e;
void bfs(int s) {
queue<int> Q;
Q.push(V[s]);
memset(vis, -1, sizeof(vis));
vis[V[s]] = 0;
while (!Q.empty()) {
int f = Q.front();
Q.pop();
for (int i = 0; i < l; i++) {
if (f + a[i] <= n + 1 && vis[f + a[i]] == -1)
vis[f + a[i]] = vis[f] + 1, Q.push(f + a[i]);
if (f - a[i] >= 1 && vis[f - a[i]] == -1)
vis[f - a[i]] = vis[f] + 1, Q.push(f - a[i]);
}
}
for (int i = 0; i < V.size(); i++)
val[s][i] = (vis[V[i]] == -1 ? 1e8 : vis[V[i]]);
}
int DP(int st) {
if (st == 0) return dp[st] = 0;
if (dp[st] != -1) return dp[st];
int ret = 1e8;
for (int i = 0; i < e.size(); i++)
if (((st ^ e[i].first) | st) == st)
ret = min(ret, DP(st ^ e[i].first) + e[i].second);
return dp[st] = ret;
}
int main() {
scanf("%d%d%d", &n, &k, &l);
memset(vis, 0, sizeof(vis));
memset(dp, -1, sizeof(dp));
memset(val, 0, sizeof(val));
for (int i = 0; i < k; i++)
scanf("%d", &x[i]), V.push_back(x[i]), V.push_back(x[i] + 1);
for (int i = 0; i < l; i++) scanf("%d", &a[i]);
for (int i = 0; i < V.size(); i++) bfs(i);
for (int i = 0; i < V.size(); i++)
for (int j = i + 1; j < V.size(); j++)
if (val[i][j] >= 0)
e.push_back(
make_pair(((1 << i) | (1 << j)), min(val[i][j], val[j][i])));
int ans = DP((1 << (2 * k)) - 1);
if (ans == 1e8) ans = -1;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, m, tot, INF;
int cdy[10086], len[10086], wzy[10086];
int sdc[10086], dis[210][210], mindis[10086];
int dp[(1 << 22) + 1];
bool vis[10086];
queue<int> que;
void SPFA(int now) {
memset(mindis, 0x3f, sizeof mindis);
que.push(sdc[now]);
mindis[sdc[now]] = 0;
vis[sdc[now]] = 1;
for (; !que.empty();) {
int u = que.front();
que.pop();
vis[u] = 0;
for (int i = 1; i <= m; ++i) {
if (u + len[i] <= n + 1 && mindis[u + len[i]] > mindis[u] + 1) {
mindis[u + len[i]] = mindis[u] + 1;
if (!vis[u + len[i]]) que.push(u + len[i]), vis[u + len[i]] = 1;
}
if (u - len[i] > 0 && mindis[u - len[i]] > mindis[u] + 1) {
mindis[u - len[i]] = mindis[u] + 1;
if (!vis[u - len[i]]) que.push(u - len[i]), vis[u - len[i]] = 1;
}
}
}
for (int i = 1; i <= tot; ++i) dis[now][i] = mindis[sdc[i]];
}
int main() {
scanf("%d%d%d", &n, &k, &m);
for (int i = 1, x; i <= k; ++i) scanf("%d", &x), cdy[x] = 1;
for (int i = 1; i <= m; ++i) scanf("%d", &len[i]);
for (int i = 1; i <= n + 1; ++i) wzy[i] = cdy[i] ^ cdy[i - 1];
for (int i = 1; i <= n + 1; ++i)
if (wzy[i]) sdc[++tot] = i;
if (tot == 0) {
printf("0");
return 0;
}
memset(dis, 0x3f, sizeof dis);
for (int i = 1; i <= tot; ++i) SPFA(i);
memset(dp, 0x3f, sizeof dp);
INF = dp[0];
dp[0] = 0;
for (int i = 0, tail; i < (1 << tot); ++i) {
tail = 0;
for (int p = 1; p <= tot; ++p)
if ((1 << (p - 1)) & i) {
tail = p;
break;
}
for (int p = 1; p <= tot; ++p)
if ((1 << (p - 1)) & i)
dp[i] = min(dp[i],
dp[i ^ (1 << (p - 1)) ^ (1 << (tail - 1))] + dis[p][tail]);
}
printf("%d\n", (dp[(1 << tot) - 1] == INF ? -1 : dp[(1 << tot) - 1]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int maxn = 10005;
const int M = 2e6 + 5;
const int inf = 0x3f3f3f3f;
bool which[maxn];
bool flag[maxn];
int a[105];
vector<int> v;
int cost[22][maxn];
int head[maxn], nxt[M], to[M];
int edgenum = -1;
void add(int u, int v) {
edgenum++;
nxt[edgenum] = head[u];
head[u] = edgenum;
to[edgenum] = v;
}
void add_edge(int u, int v) {
add(u, v);
add(v, u);
}
queue<int> q;
bool vis[maxn];
void bfs(int now) {
memset(vis, 0, sizeof(vis));
cost[now][v[now]] = 0;
q.push(v[now]);
vis[v[now]] = 1;
int u;
int i;
while (q.size()) {
u = q.front();
q.pop();
for (i = head[u]; ~i; i = nxt[i]) {
if (vis[to[i]]) continue;
vis[to[i]] = 1;
cost[now][to[i]] = cost[now][u] + 1;
q.push(to[i]);
}
}
}
void init() {
memset(head, -1, sizeof(head));
memset(cost, 0x3f, sizeof(cost));
}
int dp[(1 << 20) + 5];
int main() {
init();
int n, k, l;
scanf("%d%d%d", &n, &k, &l);
int x;
int i;
for (i = 0; i < k; i++) {
scanf("%d", &x);
which[x] = 1;
}
for (i = 0; i < l; i++) {
scanf("%d", &a[i]);
}
sort(a, a + l);
l = unique(a, a + l) - a;
for (i = 1; i <= n + 1; i++) {
if (which[i] != which[i - 1]) {
flag[i] = 1;
v.push_back(i);
}
}
int up;
int j;
for (i = 0; i < l; i++) {
for (j = 1; j + a[i] <= n + 1; j++) {
add_edge(j, j + a[i]);
}
}
int siz = v.size();
for (i = 0; i < siz; i++) bfs(i);
dp[0] = 0;
int temp;
for (i = 1; i < (1 << siz); i++) {
dp[i] = inf;
if (__builtin_popcount(i) & 1) continue;
for (j = 0; j < siz; j++) {
if (i >> j & 1) break;
}
for (temp = j + 1; temp < siz; temp++) {
if (i >> temp & 1)
dp[i] = min(dp[i], dp[i - (1 << j) - (1 << temp)] + cost[j][v[temp]]);
}
}
if (dp[(1 << siz) - 1] == inf) {
printf("-1\n");
} else
printf("%d\n", dp[(1 << siz) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10005;
struct edge {
int r, next;
} e[N * 200];
int h[N], tto;
void add(int x, int y) {
e[++tto].r = y;
e[tto].next = h[x];
h[x] = tto;
}
int a[N], n, k, l, t[N], tt;
int d[N];
int f[1048576];
int dis[25][25];
int q[N], tat;
void bfs(int x) {
int l = 1, r = 0;
tat = 0;
q[++r] = x;
d[x] = 0;
while (l <= r) {
if (tat >= tt) break;
int x = q[l++];
for (int i = h[x]; i; i = e[i].next) {
int y = e[i].r;
if (d[y] > d[x] + 1) {
d[y] = d[x] + 1;
q[++r] = y;
if (t[y]) tat++;
}
}
}
}
int main() {
cin >> n >> k >> l;
n++;
for (int i = 1; i <= k; i++) scanf("%d", &a[i]), t[a[i]] = 1;
for (int i = n; i >= 1; i--) t[i] = t[i - 1] ^ t[i];
for (int i = 1; i <= n; i++)
if (t[i]) a[++tt] = i;
int s = (1 << tt);
for (int i = 1; i <= l; i++) {
int b;
scanf("%d", &b);
for (int i = 1; i <= n - b; i++) add(i, b + i), add(i + b, i);
}
memset(dis, 63, sizeof(dis));
for (int i = 1; i <= tt; i++) {
memset(d, 63, sizeof(d));
bfs(a[i]);
for (int j = i + 1; j <= tt; j++) dis[i - 1][j - 1] = d[a[j]];
}
memset(f, 63, sizeof(f));
f[0] = 0;
for (int i = 0; i < s; i++)
if (f[i] <= 100000000) {
for (int j = 0; j < tt; j++)
if ((i & (1 << j)) == 0) {
for (int k = j + 1; k < tt; k++)
if ((i & (1 << k)) == 0) {
f[i | (1 << j) | (1 << k)] =
min(f[i | (1 << j) | (1 << k)], f[i] + dis[j][k]);
}
break;
}
}
int ans = f[s - 1] <= 100000000 ? f[s - 1] : -1;
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long rd() {
long long xx = 0, ff = 1;
char ch = getchar();
while (ch < '0' or ch > '9') {
if (ch == '-') ff = -1;
ch = getchar();
}
while (ch >= '0' and ch <= '9') {
xx = xx * 10 - '0' + ch;
ch = getchar();
}
return xx * ff;
}
const long long N = 4e4 + 10;
const long long INF = 0x3f3f3f3f3f3f3f3f;
long long n, K, m;
long long a[N], b[N];
long long len[N];
long long poi[100], p_cnt;
long long is[N];
long long tot;
long long last[N], nex[N * 110 * 2], ver[N * 110 * 2];
inline void add(long long u, long long v) {
nex[++tot] = last[u];
ver[tot] = v;
last[u] = tot;
}
long long dist[110][110];
bool vis[N];
pair<long long, long long> q[N * 10];
long long hd, ed;
void bfs(long long s, long long sign) {
memset(vis, 0, sizeof vis);
hd = ed = 0;
vis[s] = 1;
dist[sign][sign] = 0;
q[ed++] = make_pair(s, 0);
long long num = 1;
while (hd != ed) {
long long u = q[hd].first;
long long d = q[hd++].second;
for (long long i = last[u]; i; i = nex[i]) {
long long r = ver[i];
if (vis[r]) continue;
vis[r] = true;
if (is[r]) dist[sign][is[r]] = min(dist[sign][is[r]], d + 1), num++;
if (num == p_cnt) return;
q[ed++] = make_pair(r, d + 1);
}
}
}
long long f[1 << 21];
int main() {
n = rd();
K = rd();
m = rd();
for (long long i = 1; i <= K; i++) a[rd()] = 1;
for (long long i = 1; i <= m; i++) len[i] = rd();
for (long long i = 0; i <= n; i++) {
b[i] = a[i] ^ a[i + 1];
if (b[i]) {
poi[++p_cnt] = i;
is[i] = p_cnt;
}
}
memset(dist, 0x3f, sizeof dist);
for (long long i = 0; i <= n; i++)
for (long long j = 1; j <= m; j++) {
if (i - len[j] >= 0) add(i, i - len[j]);
if (i + len[j] <= n) add(i, i + len[j]);
}
for (long long i = 1; i <= p_cnt; i++) bfs(poi[i], i);
memset(f, 0x3f, sizeof f);
f[0] = 0;
for (long long i = 0; i < (1 << p_cnt); i++) {
long long j = 1;
for (; j <= p_cnt; j++)
if ((i & (1 << (j - 1))) == 0) break;
for (long long k = j + 1; k <= p_cnt; k++)
if (!(i & (1 << (k - 1))))
f[i | (1 << (j - 1)) | (1 << (k - 1))] =
min(f[i | (1 << (j - 1)) | (1 << (k - 1))], f[i] + dist[j][k]);
}
long long ans = f[(1 << p_cnt) - 1] == INF ? -1 : f[(1 << p_cnt) - 1];
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gi() {
long long ret = 0;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
char c = ch == '-' ? getchar() : ch;
while (c >= '0' && c <= '9') ret = ret * 10 + c - '0', c = getchar();
return ch == '-' ? -ret : ret;
}
const int N = 10000 + 10;
const int inf = 707406378;
int n, k, l, a[N], b[N], pos[N], f[1 << 21], dis[21][N], q[N];
void ckmin(int &x, int y) { x = x < y ? x : y; }
int main() {
n = gi();
k = gi();
l = gi();
for (int i = 1; i <= k; i += 1) {
int t = gi();
b[t] ^= 1;
b[t + 1] ^= 1;
}
int R = 0;
++n;
for (int i = 1; i <= n; i += 1)
if (b[i]) b[i] = ++R, pos[R] = i;
memset(dis, 127 / 3, sizeof dis);
memset(f, 127 / 3, sizeof f);
for (int i = 1; i <= l; i += 1) a[i] = gi();
for (int i = 1; i <= R; i += 1) {
dis[i][pos[i]] = 0;
int hd = 0, tl = 0;
q[++tl] = pos[i];
while (hd < tl) {
int r = q[++hd];
for (int j = 1; j <= l; j += 1) {
if (r + a[j] <= n && dis[i][r + a[j]] >= inf)
dis[i][r + a[j]] = dis[i][r] + 1, q[++tl] = r + a[j];
if (r - a[j] > 0 && dis[i][r - a[j]] >= inf)
dis[i][r - a[j]] = dis[i][r] + 1, q[++tl] = r - a[j];
}
}
}
f[0] = 0;
for (int z = 0; z < (1 << R); z += 1) {
for (int i = 1; i <= R; i += 1)
if (~z & (1 << (i - 1)))
for (int j = i + 1; j <= R; j += 1)
if (~z & (1 << (j - 1)))
ckmin(f[z | (1 << (i - 1)) | (1 << (j - 1))],
f[z] + dis[i][pos[j]]);
}
if (f[(1 << R) - 1] < inf)
cout << f[(1 << R) - 1];
else
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int N = 2e6 + 5;
const int K = 25;
int n, k, m, d[K][N], b[N], f[N], fir[N], len, flag[N], pos[N];
bool vis[N];
void bfs(int s, int ss) {
for (int i = 1; i <= n + 1; i++) vis[i] = false, d[s][i] = inf;
queue<int> q;
d[s][ss] = 0;
q.push(ss);
while (!q.empty()) {
int u = q.front();
q.pop();
vis[u] = false;
for (int i = 1; i <= m; i++) {
if (u + b[i] - 1 <= n)
if (d[s][u + b[i]] > d[s][u] + 1) {
d[s][u + b[i]] = d[s][u] + 1;
if (!vis[u + b[i]]) {
vis[u + b[i]] = true;
q.push(u + b[i]);
}
}
if (u - b[i] >= 1)
if (d[s][u - b[i]] > d[s][u] + 1) {
d[s][u - b[i]] = d[s][u] + 1;
if (!vis[u - b[i]]) {
vis[u - b[i]] = true;
q.push(u - b[i]);
}
}
}
}
}
int dfs(int S) {
if (!S) return 0;
if (f[S]) return f[S];
f[S] = inf;
for (int i = fir[S] + 1; i <= len; i++)
if (S & (1 << (i - 1))) {
int state = S - (1 << (fir[S] - 1)) - (1 << (i - 1));
f[S] = min(f[S], dfs(state) + d[fir[S]][pos[i]]);
}
return f[S];
}
int main() {
scanf("%d%d%d", &n, &k, &m);
for (int i = 1; i <= k; i++) {
int a;
scanf("%d", &a);
flag[a] ^= 1;
flag[a + 1] ^= 1;
}
for (int i = 1; i <= m; i++) scanf("%d", &b[i]);
for (int i = 1; i <= n + 1; i++)
if (flag[i]) {
pos[++len] = i;
bfs(len, i);
}
for (int i = 1; i < (1 << len); i++) {
for (int j = 1; j <= len; j++)
if (i & (1 << (j - 1))) {
fir[i] = j;
break;
}
}
dfs((1 << len) - 1);
if (f[(1 << len) - 1] == inf)
printf("-1");
else
printf("%d", f[(1 << len) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10101, MAXK = 20, MAXL = 101, inf = 1 << 29;
int a[N], b[N], n, K, L, len[MAXL];
vector<int> ele;
int id[N], dis[N], cost[MAXK][MAXK];
void bfs(int c, int u) {
fill(dis, dis + n + 2, inf);
fill(cost[u], cost[u] + (int)(ele).size(), inf);
dis[c] = 0;
vector<int> v;
v.push_back(c);
for (int i = 0; i < (int)(v).size(); ++i) {
c = v[i];
if (b[c] == 1) cost[u][id[c]] = dis[c];
for (int j = 0; j < L; ++j) {
if (c - len[j] > 0 && dis[c - len[j]] == inf)
dis[c - len[j]] = dis[c] + 1, v.push_back(c - len[j]);
if (c + len[j] <= n + 1 && dis[c + len[j]] == inf)
dis[c + len[j]] = dis[c] + 1, v.push_back(c + len[j]);
}
}
}
int f[1 << MAXK], who[1 << MAXK];
void Dp() {
f[0] = 0;
for (int i = 1; i < (1 << (int)(ele).size()); ++i) {
f[i] = inf;
int j = i & (-i);
for (int k = i ^ j; k; k -= k & (-k))
f[i] = min(f[i], f[i ^ j ^ (k & (-k))] + cost[who[j]][who[(k & (-k))]]);
}
int ans = f[(1 << (int)(ele).size()) - 1];
if (ans == inf) ans = -1;
printf("%d\n", ans);
}
int main() {
for (int i = 0; i < MAXK; ++i) who[1 << i] = i;
cin >> n >> K >> L;
for (int i = 0; i < K; ++i) {
int x;
cin >> x;
a[x] = 1;
}
for (int i = 0; i < L; ++i) cin >> len[i];
for (int i = 1; i < n + 2; ++i) b[i] = a[i - 1] ^ a[i];
for (int i = 1; i < n + 2; ++i)
if (b[i] == 1) id[i] = (int)(ele).size(), ele.push_back(i);
for (int i = 0; i < (int)(ele).size(); ++i) bfs(ele[i], i);
Dp();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, l, m, G[21][21], x[105], f[1 << 20 | 5], dis[21][10005];
bool a[10005];
queue<int> Qu;
vector<int> Ve;
void bfs(int id, int s) {
memset(dis[id], 0x3f, sizeof(dis[id]));
dis[id][s] = 0;
Qu.push(s);
while (!Qu.empty()) {
int u = Qu.front();
Qu.pop();
for (int i = 1; i <= l; i++) {
if (u + x[i] <= n && u + x[i] != s && dis[id][u + x[i]] == 0x3f3f3f3f)
dis[id][u + x[i]] = dis[id][u] + 1, Qu.push(u + x[i]);
if (u - x[i] >= 1 && u - x[i] != s && dis[id][u - x[i]] == 0x3f3f3f3f)
dis[id][u - x[i]] = dis[id][u] + 1, Qu.push(u - x[i]);
}
}
}
int lowbit(int x) { return x & -x; }
int main() {
scanf("%d%d%d", &n, &k, &l);
n++;
for (int i = 1; i <= k; i++) {
int x;
scanf("%d", &x);
a[x] = true;
}
for (int i = n; i >= 1; i--) {
a[i] ^= a[i - 1];
if (a[i]) Ve.push_back(i);
}
for (int i = 1; i <= l; i++) scanf("%d", &x[i]);
m = Ve.size();
for (int i = 0; i < m; i++) bfs(i, Ve[i]);
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++) G[i][j] = dis[i][Ve[j]];
int maxi = (1 << m) - 1;
memset(f, 0x3f, sizeof(f));
f[0] = 0;
for (int i = 0; i < maxi; i++) {
int A = log2(lowbit(maxi ^ i));
for (int B = 0; B < m; B++)
if (A != B && !(i & (1 << B)))
f[i ^ (1 << A) ^ (1 << B)] =
min(f[i ^ (1 << A) ^ (1 << B)], f[i] + G[A][B]);
}
printf("%d", f[maxi] == 0x3f3f3f3f ? -1 : f[maxi]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int S = 21;
const int N = 10005;
int n, m, t;
int f[1 << S], p[N], dis[N], a[N], b[N], q[N], c[S];
int g[S][S];
void bfs(int x) {
memset(dis, -1, sizeof dis);
int st = 0, ed = 1;
q[0] = x;
dis[x] = 0;
while (st < ed) {
int i = q[st++];
for (int j = 1; j <= t; ++j) {
if (i + p[j] <= n && dis[i + p[j]] == -1)
dis[i + p[j]] = dis[i] + 1, q[ed++] = i + p[j];
if (i - p[j] > 0 && dis[i - p[j]] == -1)
dis[i - p[j]] = dis[i] + 1, q[ed++] = i - p[j];
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &t);
++n;
for (int i = 1; i <= m; ++i) {
int x;
scanf("%d", &x);
a[x] ^= 1;
a[x + 1] ^= 1;
}
for (int i = 1; i <= t; ++i) scanf("%d", &p[i]);
memset(b, -1, sizeof b);
int s = 0;
for (int i = 0; i <= n; ++i)
if (a[i]) c[s] = i, b[i] = s++;
for (int i = 0; i < s; ++i) {
bfs(c[i]);
for (int j = 0; j <= n; ++j)
if (b[j] >= 0) g[i][b[j]] = dis[j] >= 0 ? dis[j] : n * 20;
}
memset(f, 1, sizeof f);
f[0] = 0;
for (int i = 0; i + 1 < 1 << s; ++i)
if (f[i] < n * 20) {
int x;
for (int j = 0; j < s; ++j)
if ((i & 1 << j) == 0) {
x = j;
break;
}
for (int j = x + 1; j < s; ++j)
if ((i & 1 << j) == 0 && f[i] + g[x][j] < f[i | 1 << x | 1 << j])
f[i | 1 << x | 1 << j] = f[i] + g[x][j];
}
printf("%d\n", f[(1 << s) - 1] < n * 20 ? f[(1 << s) - 1] : -1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 1000000009;
const double eps = 1e-6;
const int mod = 1000000007;
const int mx_n = 10010;
const int mx_l = 102, mx_k = 10;
int dist[2 * mx_k][2 * mx_k], n;
int a[mx_l], l;
int x[mx_k], k;
int dp[(1 << (2 * mx_k))];
vector<int> pos;
int bits[mx_n];
int d[mx_n];
void bfs(int s) {
for (int i = 0; i < (mx_n); ++i) d[i] = oo;
d[pos[s]] = 0;
queue<pair<int, int> > q;
q.push(make_pair(pos[s], 0));
while (!q.empty()) {
pair<int, int> cur = q.front();
q.pop();
for (int i = 0; i < (l); ++i) {
for (int dx = -1; dx <= 1; dx += 2) {
int nx = cur.first + dx * a[i];
if (nx >= 0 && nx <= n && d[nx] == oo) {
d[nx] = 1 + cur.second;
q.push(make_pair(nx, 1 + cur.second));
}
}
}
}
for (int i = 0; i < ((int)(pos.size())); ++i) dist[s][i] = d[pos[i]];
}
int main() {
scanf("%d %d %d", &n, &k, &l);
for (int i = 0; i < (k); ++i) {
scanf("%d", x + i);
bits[x[i]] = 1;
}
for (int i = 0; i < (l); ++i) scanf("%d", a + i);
for (int i = 0; i <= (n); ++i)
if (bits[i] != bits[i + 1]) pos.push_back(i);
for (int i = 0; i < ((int)(pos.size())); ++i) {
bfs(i);
for (int j = 0; j < ((int)(pos.size())); ++j)
;
;
}
dp[0] = 0;
for (int mask = 1; mask < ((1 << (int)(pos.size()))); ++mask) {
dp[mask] = oo;
for (int i = 0; i < ((int)(pos.size())); ++i)
if (mask & (1 << i)) {
for (int j = i + 1; j < ((int)(pos.size())); ++j)
if (mask & (1 << j)) {
dp[mask] =
min(dp[mask], dp[mask ^ (1 << i) ^ (1 << j)] + dist[i][j]);
}
}
}
int ans = dp[(1 << (int)(pos.size())) - 1];
if (ans == oo) ans = -1;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, xx;
int star[50005], dif[50005];
int pos[50005], tail;
int len[50005];
int dist[50005];
int cost[21][21];
int f[1 << 21];
queue<int> q;
void bfs(int s) {
memset(dist, 0x3f, sizeof(dist));
q.push(pos[s]);
dist[pos[s]] = 0;
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = 1; i <= k; i++) {
int a = x - len[i];
int b = x + len[i];
if (a >= 1 && dist[a] == 0x3f3f3f3f) {
dist[a] = dist[x] + 1;
q.push(a);
}
if (b <= n + 1 && dist[b] == 0x3f3f3f3f) {
dist[b] = dist[x] + 1;
q.push(b);
}
}
}
for (int i = 1; i <= tail; i++) {
if (dist[pos[i]] != 0x3f3f3f3f) {
cost[s][i] = dist[pos[i]];
}
}
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) cin >> xx, star[xx] = 1;
for (int i = 1; i <= k; i++) cin >> len[i];
for (int i = 1; i <= n; i++) {
if (!star[i]) continue;
dif[i] ^= 1, dif[i + 1] ^= 1;
}
for (int i = 1; i <= n + 1; i++) {
if (dif[i]) pos[++tail] = i;
}
memset(cost, 0x3f, sizeof(cost));
for (int i = 1; i <= tail; i++) bfs(i);
int all = (1 << tail) - 1;
memset(f, 0x3f, sizeof(f));
f[all] = 0;
for (int i = all; i >= 0; i--) {
for (int j = 1; j <= tail; j++) {
if (!((1 << (j - 1)) & i)) continue;
for (int k = j + 1; k <= tail; k++) {
if (!((1 << (k - 1)) & i)) continue;
int x = ~((~i) | (1 << (j - 1)) | (1 << (k - 1)));
f[x] = min(f[x], f[i] + cost[j][k]);
}
}
}
if (f[0] == 0x3f3f3f3f)
puts("-1");
else
cout << f[0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
int t, cnt, n, m, k, dis[N], a[N], tr[N], g[25][25], cf[N], cf2[N], dp[3048576];
void bfs(int s) {
for (int i = 1; i <= n + 1; i++) dis[i] = 0x3f3f3f3f;
queue<int> q;
dis[s] = 0;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 1; i <= m; i++) {
int v1 = u + a[i];
if (v1 <= n + 1 && dis[v1] == 0x3f3f3f3f) {
dis[v1] = dis[u] + 1;
q.push(v1);
}
int v2 = u - a[i];
if (v2 >= 1 && dis[v2] == 0x3f3f3f3f) {
dis[v2] = dis[u] + 1;
q.push(v2);
}
}
}
for (int i = 1; i <= n + 1; i++)
if (tr[i] != -1) g[tr[s]][tr[i]] = dis[i];
}
int main() {
scanf("%d%d%d", &n, &k, &m);
for (int i = 1; i <= k; i++) {
scanf("%d", &t);
cf2[t] = 1;
}
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n + 1; i++) cf[i] = cf2[i] ^ cf2[i - 1];
cnt = -1;
for (int i = 1; i <= n + 1; i++) tr[i] = -1;
for (int i = 1; i <= n + 1; i++)
if (cf[i]) tr[i] = ++cnt;
for (int i = 1; i <= n + 1; i++)
if (cf[i]) bfs(i);
for (int i = 1; i < (1 << (cnt + 1)); i++) dp[i] = 0x3f3f3f3f;
for (int i = 0; i < (1 << (cnt + 1)); i++) {
if (dp[i] == 0x3f3f3f3f) continue;
for (int j = 0; j <= cnt; j++) {
if ((i >> j) & 1) continue;
for (int k = j + 1; k <= cnt; k++)
if (((i >> k) & 1) == 0)
dp[i + (1 << j) + (1 << k)] =
min(dp[i + (1 << j) + (1 << k)], dp[i] + g[j][k]);
}
}
printf("%d", (dp[(1 << (cnt + 1)) - 1] == 0x3f3f3f3f)
? -1
: dp[(1 << (cnt + 1)) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, l;
int num = 1;
int a[10010], x[25];
struct node {
int to;
int next;
} road[3000000];
int head[10010];
int d[10010], q[10010], L = 1, R = 0;
int cost[25][25];
int f[(1 << 20) + 5];
void build(int from, int to) {
road[++num].next = head[from];
road[num].to = to;
head[from] = num;
}
void bfs(int num) {
int s = x[num];
memset(d, 0x3f, sizeof(d));
L = 1, R = 0;
d[s] = 0;
q[++R] = s;
while (L <= R) {
int x = q[L];
L++;
for (int i = head[x]; i; i = road[i].next) {
int y = road[i].to;
if (d[y] > 1e9) {
d[y] = d[x] + 1;
q[++R] = y;
}
}
}
for (int i = 1; i <= k; i++) {
cost[num][i] = d[x[i]];
}
}
int main() {
scanf("%d%d%d", &n, &k, &l);
for (int i = 1; i <= k; i++) {
int X;
scanf("%d", &X);
a[X] = 1;
}
n++;
k = 0;
for (int i = 1; i <= n; i++) {
if (a[i] ^ a[i - 1]) x[++k] = i;
}
if (k & 1) {
printf("-1\n");
return 0;
}
memset(a, 0, sizeof(a));
for (int i = 1; i <= l; i++) {
scanf("%d", &a[i]);
for (int j = 1; j <= n; j++) {
if (j + a[i] <= n) build(j, j + a[i]);
if (j - a[i] >= 1) build(j, j - a[i]);
}
}
for (int i = 1; i <= k; i++) {
bfs(i);
}
memset(f, 0x3f, sizeof(f));
f[0] = 0;
int tot = (1 << k) - 1;
for (int i = 1; i <= tot; i++) {
int cnt = 0;
for (int j = 1; j <= k; j++) {
if ((i >> (j - 1)) & 1) cnt++;
}
if (cnt & 1) continue;
for (int j = 1; j <= k; j++) {
if (((i >> (j - 1)) & 1) == 0) continue;
for (int t = 1; t < j; t++) {
if (((i >> (t - 1)) & 1) == 0) continue;
if (j == t) continue;
f[i] = min(f[i], f[i ^ (1 << (j - 1)) ^ (1 << (t - 1))] + cost[j][t]);
}
}
}
printf("%d\n", f[tot] > 1e9 ? -1 : f[tot]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mn = 11000, mm = 110, inf = 1 << 28;
int n, m, l, tt, L;
int bi[mm], a[mm], e[mm], que[mn];
int g[mm][mn], f[mm * mn];
bool c[mn];
int main() {
scanf("%d%d%d", &n, &m, &l);
int i, j, k, s, r, h;
for (i = 1; i <= m; ++i) scanf("%d", &j), c[j] = 1;
for (i = 1; i <= l; ++i) scanf("%d", a + i);
for (i = 1; i <= n + 1; ++i)
if (c[i] != c[i - 1]) e[++tt] = i;
for (i = 0; i <= tt; ++i) bi[i] = 1 << i;
fill(g[0], g[tt + 1], inf);
for (s = 1; s <= tt; ++s) {
int *d = g[s];
d[e[s]] = 0;
que[r = h = 1] = e[s];
while (r <= h) {
i = que[r++];
for (j = 1; j <= l; ++j) {
k = i + a[j];
if (k <= n + 1 && d[i] + 1 < d[k]) d[k] = d[i] + 1, que[++h] = k;
k = i - a[j];
if (k >= 1 && d[i] + 1 < d[k]) d[k] = d[i] + 1, que[++h] = k;
}
}
}
fill(f, f + bi[tt], inf);
f[0] = 0;
for (i = 0; i <= bi[tt] - 1; ++i) {
for (j = 1; j <= tt && ((i & bi[j - 1])) > 0; ++j)
;
for (k = j + 1; k <= tt; ++k)
if ((i & bi[k - 1]) == 0) {
int s = i ^ bi[j - 1] ^ bi[k - 1];
f[s] = min(f[s], f[i] + g[j][e[k]]);
}
}
if (f[bi[tt] - 1] < inf)
printf("%d\n", f[bi[tt] - 1]);
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
const int P = 1048576 + 10;
const int Y = 30;
int tr[N];
int cnt;
int cf[N];
int a[N];
int n;
int m;
int k;
int cst[Y][Y];
int d[N];
int dp[P];
queue<int> q;
inline void bfs(int s) {
for (int i = 1; i <= n + 1; i++) d[i] = 0x3f3f3f3f;
d[s] = 0;
int nw;
int i = 1;
for (q.push(s); !q.empty();)
for (nw = q.front(), q.pop(), i = 1; i <= m; i++) {
int v1 = nw + a[i];
if (v1 <= n + 1 && d[v1] == 0x3f3f3f3f) d[v1] = d[nw] + 1, q.push(v1);
int v2 = nw - a[i];
if (v2 >= 1 && d[v2] == 0x3f3f3f3f) d[v2] = d[nw] + 1, q.push(v2);
}
for (int i = 1; i <= n + 1; i++)
if (tr[i] != -1) cst[tr[s]][tr[i]] = d[i];
}
int main() {
scanf("%d%d%d", &n, &k, &m);
for (int i = 1, t; i <= k; i++) {
scanf("%d", &t);
cf[t] = 1;
}
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
for (int i = n + 1; i >= 1; i--) cf[i] ^= cf[i - 1];
cnt = -1;
for (int i = 1; i <= n + 1; i++) tr[i] = -1;
for (int i = 1; i <= n + 1; i++)
if (cf[i]) tr[i] = ++cnt;
for (int i = 1; i <= n + 1; i++)
if (cf[i]) bfs(i);
for (int i = 1; i < (1 << (cnt + 1)); i++) dp[i] = 0x3f3f3f3f;
for (int i = 0; i < (1 << (cnt + 1)); i++) {
if (dp[i] == 0x3f3f3f3f) continue;
for (int j = 0; j <= cnt; j++) {
if ((i >> j) & 1) continue;
for (int k = j + 1; k <= cnt; k++)
if (((i >> k) & 1) == 0)
dp[i + (1 << j) + (1 << k)] =
min(dp[i + (1 << j) + (1 << k)], dp[i] + cst[j][k]);
}
}
int ans = dp[(1 << (cnt + 1)) - 1];
printf("%d", (ans == 0x3f3f3f3f) ? -1 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);
int n, k, l;
int m;
int seq[10010];
int indexes[30];
int step[200];
int dist[30][10010];
int dp[1 << 20];
void calcDist(int s) {
queue<pair<int, int> > que;
dist[s][indexes[s]] = 0;
que.push(make_pair(indexes[s], 0));
while (!que.empty()) {
int x = que.front().first;
int ncost = que.front().second + 1;
que.pop();
for (int i = 0; i < (int)(l); i++) {
int nx = x + step[i];
if (nx > n || dist[s][nx] != -1) {
continue;
}
dist[s][nx] = ncost;
que.push(make_pair(nx, ncost));
}
for (int i = 0; i < (int)(l); i++) {
int nx = x - step[i];
if (nx < 0 || dist[s][nx] != -1) {
continue;
}
dist[s][nx] = ncost;
que.push(make_pair(nx, ncost));
}
}
}
int calc(int depth, int use) {
if (dp[use] != -1) {
return dp[use];
}
if (depth == m) {
return dp[use] = 0;
}
if (use & (1 << depth)) {
return calc(depth + 1, use);
}
int ret = (1 << 24);
for (int i = 0; i < (int)(m); i++) {
if (i == depth) {
continue;
}
if (use & (1 << i)) {
continue;
}
int d = dist[depth][indexes[i]];
if (d == -1) {
continue;
}
int nuse = use ^ (1 << depth) ^ (1 << i);
ret = min(ret, calc(depth + 1, nuse) + d);
}
return dp[use] = ret;
}
int main() {
while (scanf("%d %d %d", &n, &k, &l) > 0) {
memset((seq), 0, sizeof(seq));
memset((dist), -1, sizeof(dist));
memset((dp), -1, sizeof(dp));
m = 0;
for (int i = 0; i < (int)(k); i++) {
int x;
scanf("%d", &x);
x--;
seq[x] ^= 1;
seq[x + 1] ^= 1;
}
for (int i = 0; i < (int)(n + 1); i++) {
if (seq[i]) {
indexes[m++] = i;
}
}
for (int i = 0; i < (int)(l); i++) {
scanf("%d", &step[i]);
}
for (int s = 0; s < (int)(m); s++) {
calcDist(s);
}
int ans = calc(0, 0);
if (ans > (1 << 20)) {
puts("-1");
} else {
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000;
const int MAX = 11100;
const int inf = 1000 * 1000 * 1000;
const int p1 = 104393321, p2 = 104393329;
int n, k, l, mark[MAX], dis[30][MAX], L[200], dp[1 << 21];
bitset<MAX> sys;
vector<int> adj[MAX], token;
void bfs(int cur) {
int v = token[cur];
memset(mark, 0, sizeof mark);
mark[v] = 1;
dis[cur][v] = 0;
queue<int> q;
q.push(v);
while (!q.empty()) {
v = q.front();
q.pop();
for (int i = (0); i < int(adj[v].size()); ++i) {
int u = adj[v][i];
if (!mark[u]) {
mark[u] = 1;
dis[cur][u] = dis[cur][v] + 1;
q.push(u);
}
}
}
}
int FIND(int x) {
int s = 0;
while ((((x) >> s) & 1) == 0) s++;
return s;
}
int main(int argc, char **argv) {
ios::sync_with_stdio(0);
cin >> n >> k >> l;
int x;
for (int i = (0); i < int(k); ++i) {
cin >> x;
x--;
sys.flip(x);
sys.flip(x + 1);
}
for (int i = (0); i < int(l); ++i) {
cin >> L[i];
}
++n;
for (int i = (0); i < int(n); ++i) {
if (sys[i]) token.push_back(i);
for (int j = (0); j < int(l); ++j) {
if (i + L[j] < n) adj[i].push_back(i + L[j]);
if (i - L[j] >= 0) adj[i].push_back(i - L[j]);
}
}
for (int i = (0); i < int(token.size()); ++i)
for (int j = (0); j < int(n); ++j) dis[i][j] = inf;
for (int i = (0); i < int(token.size()); ++i) bfs(i);
dp[0] = 0;
for (int i = (1); i < int(1 << token.size()); ++i) {
int s = FIND(i);
dp[i] = inf;
for (int j = (0); j < int(token.size()); ++j)
if (s != j && (((i) >> j) & 1))
dp[i] = min(dis[s][token[j]] + dp[i ^ (1 << j) ^ (1 << s)], dp[i]);
}
int ans = dp[(1 << token.size()) - 1];
if (ans <= 0 || ans >= inf)
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void bfs(int s, bitset<10000 + 5>& panel, int dis[], int a[], int L, int N,
int id[], int size) {
fill(dis, dis + size, 1 << 24);
dis[id[s]] = 0;
int cal_dis[10000 + 5];
fill(cal_dis, cal_dis + 10000 + 5, -1);
cal_dis[s] = 0;
queue<int> que;
que.push(s);
while (!que.empty()) {
int cur = que.front();
que.pop();
for (int i = 0; i < L; ++i) {
int v = cur + a[i];
if (v >= N || v == s || cal_dis[v] != -1) continue;
cal_dis[v] = cal_dis[cur] + 1;
if (panel[v] == 1) {
dis[id[v]] = cal_dis[v];
} else {
que.push(v);
}
}
for (int i = 0; i < L; ++i) {
int v = cur - a[i];
if (v < 0 || v == s || cal_dis[v] != -1) continue;
cal_dis[v] = cal_dis[cur] + 1;
if (panel[v] == 1) {
dis[id[v]] = cal_dis[v];
} else {
que.push(v);
}
}
}
}
int dp[1 << 24];
int main() {
int N, K, L;
bitset<10000 + 5> panel;
int x[10 + 5], a[100 + 5];
cin >> N >> K >> L;
for (int i = 0; i < K; ++i) {
cin >> x[i];
panel[x[i]] = 1;
}
for (int i = 0; i < L; ++i) {
cin >> a[i];
}
panel = panel ^ (panel >> 1);
vector<int> vertices;
int dis[24][24];
int id[10000 + 5];
int size = 0;
for (int i = 0; i < N + 1; ++i) {
if (panel[i] == 1) {
id[i] = size++;
}
}
for (int i = 0; i < N + 1; ++i) {
if (panel[i] == 1) {
bfs(i, panel, dis[id[i]], a, L, N + 1, id, size);
}
}
int mask = 1 << size;
fill(dp, dp + mask, 1 << 24);
dp[0] = 0;
for (int i = 3; i < mask; ++i) {
for (int k = 0; k < size; ++k) {
if (i & (1 << k)) {
for (int j = k + 1; j < size; ++j) {
if (i & (1 << j)) {
int p = i - (1 << k) - (1 << j);
if (dp[p] < (1 << 24) && dis[k][j] < (1 << 24)) {
dp[i] = min(dp[i], dp[p] + dis[k][j]);
}
}
}
}
}
}
if (dp[mask - 1] < 1 << 24)
cout << dp[mask - 1] << endl;
else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long llINF = 1e18;
const int MAXN = 22;
const int MAXM = 1 << MAXN;
const int MAXL = 2e4 + 5;
int n, k, m, tot;
int pos[MAXN], dis[MAXL], cost[MAXN][MAXN], a[MAXL], len[105], vis[MAXL],
f[MAXM];
queue<int> q;
void bfs(int s) {
memset(dis, 0x3f, sizeof(dis));
memset(vis, 0, sizeof(vis));
dis[pos[s]] = 0;
vis[pos[s]] = 1;
q.push(pos[s]);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 1; i <= m; i++) {
int v1 = u + len[i], v2 = u - len[i];
if (v1 <= n && !vis[v1]) {
dis[v1] = dis[u] + 1;
vis[v1] = 1;
q.push(v1);
}
if (v2 >= 0 && !vis[v2]) {
dis[v2] = dis[u] + 1;
vis[v2] = 1;
q.push(v2);
}
}
}
for (int i = 1; i <= tot; i++) cost[s][i] = dis[pos[i]];
}
void checkmin(int &x, int y) {
if (x > y) x = y;
}
int main() {
scanf("%d%d%d", &n, &k, &m);
for (int i = 1, x; i <= k; i++) {
scanf("%d", &x);
a[x] = 1;
}
for (int i = 1; i <= m; i++) scanf("%d", &len[i]);
for (int i = 0; i <= n; i++) a[i] ^= a[i + 1];
for (int i = 0; i <= n; i++) {
if (a[i]) pos[++tot] = i;
}
for (int i = 1; i <= tot; i++) bfs(i);
memset(f, 0x3f, sizeof(f));
f[0] = 0;
int maxState = (1 << tot) - 1;
for (int S = 0; S <= maxState; S++) {
for (int i = 1; i <= tot; i++) {
if (S & (1 << (i - 1))) continue;
for (int j = i + 1; j <= tot; j++) {
if (S & (1 << (j - 1))) continue;
checkmin(f[S | (1 << (i - 1)) | (1 << (j - 1))], f[S] + cost[i][j]);
}
}
}
printf("%d\n", (f[maxState] >= INF ? -1 : f[maxState]));
return 0;
}
|
#include <bits/stdc++.h>
namespace IO {
const int IN_LEN = 1 << 18 | 1;
static char buf[IN_LEN], *s, *t;
inline int Getchar(void) {
return s == t && (t = (s = buf) + fread(buf, 1, IN_LEN, stdin)),
s == t ? -1 : *s++;
}
template <class T>
inline void read(T& x) {
static int c, f;
for (c = Getchar(), f = 0; c < '0' || c > '9'; c = Getchar())
if (c == '-') f = 1;
for (x = 0; c <= '9' && c >= '0'; c = Getchar()) x = x * 10 + c - 48;
x = f ? -x : x;
}
} // namespace IO
using IO::read;
const int MAXN = 1e5 + 11, MAXK = 23, MAXS = 1 << 20;
int n, dis[MAXN], num[MAXN], dat[MAXN], d[MAXK][MAXK], siz[MAXN], m, k;
int que[MAXN], he, ta, f[MAXS], cnt;
void bfs(int x) {
static int u;
memset(dis, 0x3f, sizeof dis);
dis[que[he = ta = 1] = x] = 0;
while (he <= ta) {
u = que[he++];
for (int i = 1; i <= m; ++i) {
if (u - siz[i] > 0 && dis[u - siz[i]] == 0x3f3f3f3f)
dis[que[++ta] = u - siz[i]] = dis[u] + 1;
if (u + siz[i] <= n && dis[u + siz[i]] == 0x3f3f3f3f)
dis[que[++ta] = u + siz[i]] = dis[u] + 1;
}
}
for (int i = 1; i <= n; ++i)
if (num[i]) d[num[x]][num[i]] = dis[i];
}
int dp(int S) {
if (!S) return 0;
if (~f[S]) return f[S];
int& res = f[S];
int st = -1;
res = 0x3f3f3f3f;
for (int i = 0; i < cnt; ++i)
if ((S >> i) & 1) {
if (st == -1)
st = i;
else
res = ((res) > (dp(S ^ (1 << i) ^ (1 << st)) + d[st + 1][i + 1])
? (dp(S ^ (1 << i) ^ (1 << st)) + d[st + 1][i + 1])
: (res));
}
return res;
}
int main(void) {
read(n), read(k), read(m);
for (int i = 1, t; i <= k; ++i) {
read(t);
dat[t] ^= 1;
}
for (int i = 1; i <= m; ++i) read(siz[i]);
++n;
for (int i = n; i; --i) dat[i] ^= dat[i - 1];
for (int i = 1; i <= n; ++i)
if (dat[i]) num[i] = ++cnt;
for (int i = 1; i <= n; ++i)
if (dat[i]) bfs(i);
memset(f, -1, sizeof f);
int res = dp((1 << cnt) - 1);
printf(res == 0x3f3f3f3f ? "-1" : "%d", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2000000000;
int n, k, l;
int m[10010], a[110];
int v[10010], b[10010];
vector<int> p;
int dist[10100];
int d[25][25];
int mem[3000000];
inline int abs(int x) { return max(x, -x); }
void bfs(int x) {
memset(dist, -1, sizeof dist);
queue<int> Q;
Q.push(p[x]);
dist[p[x]] = 0;
int node;
while (!Q.empty()) {
node = Q.front();
Q.pop();
for (int i = 0; i < l; ++i) {
if (node - a[i] >= 0 && dist[node - a[i]] == -1) {
dist[node - a[i]] = dist[node] + 1;
Q.push(node - a[i]);
}
if (node + a[i] <= n && dist[node + a[i]] == -1) {
dist[node + a[i]] = dist[node] + 1;
Q.push(node + a[i]);
}
}
}
for (int i = 0; i < p.size(); ++i) d[x][i] = dist[p[i]];
}
int solve(int mask) {
if (mem[mask] != -1) return mem[mask];
if (mask == (1 << p.size()) - 1) return 0;
int x = -1;
for (int i = 0; i < p.size(); ++i)
if (~mask >> i & 1) {
x = i;
break;
}
int _mask = mask | 1 << x;
int ret = INF;
for (int i = 0; i < p.size(); ++i) {
if ((~_mask >> i & 1) && (i != x)) {
int tmp = solve(_mask | 1 << i);
if (tmp != INF && d[x][i] != -1) ret = min(ret, tmp + d[x][i]);
}
}
return mem[mask] = ret;
}
int main(void) {
scanf("%d%d%d", &n, &k, &l);
for (int i = 0; i < k; ++i) {
int x;
scanf("%d", &x);
v[x] = 1;
}
for (int i = 0; i < l; ++i) scanf("%d", &a[i]);
for (int i = 0; i <= n; ++i)
if (v[i] != v[i + 1]) b[i] = 1;
for (int i = 0; i <= n; ++i)
if (b[i] == 1) p.push_back(i);
for (int i = 0; i < p.size(); ++i) bfs(i);
memset(mem, -1, sizeof mem);
int sol = solve(0);
printf("%d\n", sol == INF ? -1 : sol);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
const int P = 1048576 + 10;
const int Y = 30;
int vis[N];
int cnt;
int book[N];
int a[N];
int n;
int m;
int k;
int addis[Y][Y];
int dis[N];
int dp[P];
queue<int> q;
inline void bfs(int s) {
for (int i = 1; i <= n + 1; i++) dis[i] = 0x3f3f3f3f;
dis[s] = 0;
int nw;
int i = 1;
for (q.push(s); !q.empty();)
for (nw = q.front(), q.pop(), i = 1; i <= m; i++) {
int v1 = nw + a[i];
if (v1 <= n + 1 && dis[v1] == 0x3f3f3f3f)
dis[v1] = dis[nw] + 1, q.push(v1);
int v2 = nw - a[i];
if (v2 >= 1 && dis[v2] == 0x3f3f3f3f) dis[v2] = dis[nw] + 1, q.push(v2);
}
for (int i = 1; i <= n + 1; i++)
if (vis[i] != -1) addis[vis[s]][vis[i]] = dis[i];
}
int main() {
scanf("%d%d%d", &n, &k, &m);
for (int i = 1, t; i <= k; i++) {
scanf("%d", &t);
book[t] = 1;
}
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
for (int i = n + 1; i >= 1; i--) book[i] ^= book[i - 1];
cnt = -1;
for (int i = 1; i <= n + 1; i++) vis[i] = -1;
for (int i = 1; i <= n + 1; i++)
if (book[i]) vis[i] = ++cnt;
for (int i = 1; i <= n + 1; i++)
if (book[i]) bfs(i);
for (int i = 1; i < (1 << (cnt + 1)); i++) dp[i] = 0x3f3f3f3f;
for (int i = 0; i < (1 << (cnt + 1)); i++) {
if (dp[i] == 0x3f3f3f3f) continue;
for (int j = 0; j <= cnt; j++) {
if ((i >> j) & 1) continue;
for (int k = j + 1; k <= cnt; k++)
if (((i >> k) & 1) == 0)
dp[i + (1 << j) + (1 << k)] =
min(dp[i + (1 << j) + (1 << k)], dp[i] + addis[j][k]);
}
}
int ans = dp[(1 << (cnt + 1)) - 1];
printf("%d", (ans == 0x3f3f3f3f) ? -1 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10010;
const int inf = 0x3fffffff;
int dp[1 << 20], w[20][20], d[maxn], x[20], a[100];
int main() {
int n, k, l;
while (scanf("%d%d%d", &n, &k, &l) == 3) {
for (int i = 0; i < k; i++) scanf("%d", &x[i]);
for (int i = 0; i < l; i++) scanf("%d", &a[i]);
sort(a, a + l);
l = unique(a, a + l) - a;
set<int> iset;
for (int i = 0; i < k; i++) {
if (iset.find(x[i] - 1) != iset.end())
iset.erase(x[i] - 1);
else
iset.insert(x[i] - 1);
if (iset.find(x[i]) != iset.end())
iset.erase(x[i]);
else
iset.insert(x[i]);
}
k = copy(iset.begin(), iset.end(), x) - x;
for (int i = 0; i < k; i++) {
fill(d, d + n + 1, inf);
d[x[i]] = 0;
priority_queue<pair<int, int> > pq;
pq.push(make_pair(0, x[i]));
while (!pq.empty()) {
int s = pq.top().second;
int t = -pq.top().first;
pq.pop();
if (d[s] != t) continue;
for (int j = 0; j < l; j++) {
if (s - a[j] >= 0 && d[s - a[j]] > t + 1) {
d[s - a[j]] = t + 1;
pq.push(make_pair(-d[s - a[j]], s - a[j]));
}
if (s + a[j] <= n && d[s + a[j]] > t + 1) {
d[s + a[j]] = t + 1;
pq.push(make_pair(-d[s + a[j]], s + a[j]));
}
}
}
for (int j = 0; j < k; j++) w[i][j] = d[x[j]];
}
fill(dp, dp + (1 << k), inf);
dp[0] = 0;
for (int mask = 0; mask < (1 << k); mask++) {
int u;
for (u = 0; u < k; u++)
if ((mask & (1 << u)) == 0) break;
if (u >= k) continue;
for (int v = u + 1; v < k; v++)
if ((mask & (1 << v)) == 0) {
int _mask = mask ^ (1 << u) ^ (1 << v);
dp[_mask] = min(dp[_mask], dp[mask] + w[u][v]);
}
}
printf("%d\n", dp[(1 << k) - 1] == inf ? -1 : dp[(1 << k) - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10005, INF = 1000000005;
int f[N], n, m, z, x, y, K, len[205], mzt, zt, g[1048577], p[25], pn;
int h, t, dis[25][25], que[N];
bool c[N];
inline void spfa(int l, int x) {
memset(f, 127 / 3, sizeof(f));
h = 0;
que[t = 1] = x;
c[x] = true;
f[x] = 0;
int now;
while (h < t) {
now = que[++h];
for (int j = 1; j <= m; ++j)
for (int k = -1; k <= 1; k += 2)
if (now + len[j] * k >= 1 && now + len[j] * k <= n &&
f[now + len[j] * k] > f[now] + 1) {
f[now + len[j] * k] = f[now] + 1;
if (c[now + len[j] * k] == false) {
que[++t] = now + len[j] * k;
c[now + len[j] * k] = true;
}
}
c[now] = false;
}
for (int i = 1; i <= pn; ++i) dis[l][i] = f[p[i]];
}
int main() {
scanf("%d%d%d", &n, &K, &m);
++n;
for (int i = 1; i <= K; ++i) {
scanf("%d", &x);
c[x] ^= 1;
c[x + 1] ^= 1;
}
for (int i = 1; i <= n; ++i)
if (c[i] == true) p[++pn] = i;
for (int i = 1; i <= m; ++i) scanf("%d", &len[i]);
for (int i = 1; i < pn; ++i)
for (int j = i + 1; j <= pn; ++j) spfa(i, p[i]);
memset(g, 127 / 3, sizeof(g));
g[0] = 0;
mzt = (1 << pn) - 1;
for (int i = 0; i <= mzt; ++i)
if (g[i] <= 10000005) {
for (int j = 1; j < pn; ++j)
for (int k = j + 1; k <= pn; ++k)
if ((i & (1 << (j - 1))) == 0 && (i & (1 << (k - 1))) == 0)
g[i | (1 << (j - 1)) | (1 << (k - 1))] =
min(g[i | (1 << (j - 1)) | (1 << (k - 1))], g[i] + dis[j][k]);
}
if (g[mzt] <= 10000005)
printf("%d", g[mzt]);
else
printf("-1");
fclose(stdin);
fclose(stdout);
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K, L;
int x[30], a[110];
int dist[10010];
int graph[30][30];
int dp[(1 << 20)];
queue<int> q;
void add(int pos, int d) {
if (d < dist[pos]) {
dist[pos] = d;
q.push(pos);
}
}
void bfs(int start) {
int i;
for ((i) = 0; (i) < (int)(N + 1); (i)++) dist[i] = (1 << 29);
add(start, 0);
while (!q.empty()) {
int pos = q.front();
q.pop();
for ((i) = 0; (i) < (int)(L); (i)++) {
if (pos - a[i] >= 0) add(pos - a[i], dist[pos] + 1);
if (pos + a[i] <= N) add(pos + a[i], dist[pos] + 1);
}
}
}
int main(void) {
int mask, i, j;
cin >> N >> K >> L;
for ((i) = 0; (i) < (int)(K); (i)++) {
cin >> x[i];
x[i]--;
}
for ((i) = 0; (i) < (int)(L); (i)++) cin >> a[i];
for ((i) = 0; (i) < (int)(K); (i)++) x[K + i] = x[i] + 1;
K *= 2;
for ((i) = 0; (i) < (int)(K); (i)++) {
bfs(x[i]);
for ((j) = 0; (j) < (int)(K); (j)++) graph[i][j] = dist[x[j]];
}
for ((i) = 0; (i) < (int)((1 << K)); (i)++) dp[i] = (1 << 29);
dp[0] = 0;
for ((mask) = 0; (mask) < (int)((1 << K)); (mask)++)
if (mask != 0) {
for ((i) = 0; (i) < (int)(K); (i)++)
if (mask & (1 << i)) break;
for ((j) = 0; (j) < (int)(K); (j)++)
if (mask & (1 << j))
if (i != j)
dp[mask] =
min(dp[mask], dp[mask ^ (1 << i) ^ (1 << j)] + graph[i][j]);
}
int ans = dp[(1 << K) - 1];
if (ans == (1 << 29))
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400050;
int b[700], n, m, k;
int a[500], f[N];
int pos[500], g[4005000];
int cost[500][500];
inline int to(int x) { return 1 << x; }
queue<int> q;
int cnt = 1;
void bfs(int s) {
memset(f, 0x3f, sizeof(f));
f[s] = 0;
q.push(s);
while (q.size()) {
int x = q.front();
q.pop();
for (int i = 1; i <= m; i++) {
int y = x + b[i];
if (y <= n + 1 && f[y] > n) {
f[y] = f[x] + 1;
q.push(y);
}
y = x - b[i];
if (y > 0 && f[y] > n) {
f[y] = f[x] + 1;
q.push(y);
}
}
}
}
int main() {
cin >> n >> k >> m;
for (int i = 1; i <= k; i++) cin >> a[i];
sort(a + 1, a + k + 1);
pos[1] = a[1];
for (int i = 2; i <= k; i++)
if (a[i] != a[i - 1] + 1) {
pos[++cnt] = a[i - 1] + 1;
pos[++cnt] = a[i];
}
pos[++cnt] = a[k] + 1;
for (int i = 1; i <= m; i++) cin >> b[i];
for (int i = 1; i <= cnt; i++) {
bfs(pos[i]);
for (int j = 1; j <= cnt; j++) cost[i][j] = f[pos[j]];
}
memset(g, 0x3f, sizeof(g));
g[0] = 0;
for (int i = 1; i < 1 << cnt; i++) {
int tmp = 0;
for (int j = 1; j <= cnt; j++)
if (i & to(j - 1)) tmp++;
if (tmp & 1) continue;
for (int j = 1; j <= cnt; j++)
if (i & to(j - 1))
for (int k = j + 1; k <= cnt; k++)
if (i & to(k - 1))
g[i] = min(g[i], g[i ^ to(k - 1) ^ to(j - 1)] + cost[k][j]);
}
if (g[(1 << cnt) - 1] >= 1000000)
cout << -1 << endl;
else
cout << g[(1 << cnt) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void cuantospasos(vector<int> &a, int posini, vector<int> &d, int n,
vector<int> &indice0, vector<int> &indice1) {
if (indice0[posini] != -1) d[indice0[posini]] = 0;
if (indice1[posini] != -1) d[indice1[posini]] = 0;
vector<int> v;
vector<int> visitado(n + 1, 0);
v.push_back(posini);
visitado[posini] = 1;
int pasos = 0;
while (not v.empty()) {
pasos++;
vector<int> nextv;
for (int i = 0; i < int(v.size()); i++) {
int pos = v[i];
for (int j = 0; j < int(a.size()); j++) {
int len = a[j];
if (pos - len >= 0 and visitado[pos - len] == 0) {
int nextpos = pos - len;
if (indice0[nextpos] != -1) d[indice0[nextpos]] = pasos;
if (indice1[nextpos] != -1) d[indice1[nextpos]] = pasos;
visitado[nextpos] = 1;
nextv.push_back(nextpos);
}
if (pos + len < n + 1 and visitado[pos + len] == 0) {
int nextpos = pos + len;
if (indice0[nextpos] != -1) d[indice0[nextpos]] = pasos;
if (indice1[nextpos] != -1) d[indice1[nextpos]] = pasos;
visitado[nextpos] = 1;
nextv.push_back(nextpos);
}
}
}
v = nextv;
}
}
int main() {
int n, k, l;
cin >> n >> k >> l;
vector<int> indice0(n + 1, -1);
vector<int> indice1(n + 1, -1);
vector<int> posuno(k);
for (int i = 0; i < k; i++) {
cin >> posuno[i];
posuno[i]--;
indice0[posuno[i]] = i;
indice1[posuno[i] + 1] = i + k;
}
vector<int> a(l);
for (int i = 0; i < l; i++) cin >> a[i];
vector<vector<int> > d(2 * k, vector<int>(2 * k, 100000000));
for (int i = 0; i < k; i++) {
cuantospasos(a, posuno[i], d[i], n, indice0, indice1);
cuantospasos(a, posuno[i] + 1, d[i + k], n, indice0, indice1);
}
vector<vector<int> > cuantos(1 << k, vector<int>(2 * k, 100000000));
vector<int> lenciclo(1 << k);
for (int c = 1; c < (1 << k); c++) {
int bit = k - 1;
while (((1 << bit) & c) == 0) bit--;
for (int b = 0; b <= bit; b++) {
if (((1 << b) & c) == 0 or b == bit) {
for (int lado = 0; lado < 2; lado++) {
if (c - (1 << bit) == 0) {
cuantos[c][k * lado + b] = d[k * lado + b][k + bit];
} else {
for (int bb = 0; bb < bit; bb++) {
if ((1 << bb) & c) {
cuantos[c][k * lado + b] =
min(cuantos[c][k * lado + b],
d[k * lado + b][bb] + cuantos[c - (1 << bb)][k + bb]);
cuantos[c][k * lado + b] =
min(cuantos[c][k * lado + b],
d[k * lado + b][k + bb] + cuantos[c - (1 << bb)][bb]);
}
}
}
}
}
}
lenciclo[c] = cuantos[c][bit];
}
vector<int> coste(1 << k, 100000000);
for (int c = 1; c < (1 << k); c++) {
coste[c] = min(coste[c], lenciclo[c]);
for (int subc = 1; subc < c; subc++)
if ((c & subc) == subc)
coste[c] = min(coste[c], coste[subc] + lenciclo[c - subc]);
}
if (coste[(1 << k) - 1] >= 100000000)
cout << -1 << endl;
else
cout << coste[(1 << k) - 1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, s, d[20000002], f[10002], gr[22][22], fx[10002], g[102], h, j, k, l, i,
n, m;
queue<pair<int, int> > q;
int main() {
cin >> n >> m >> k;
for (i = 0; i < m; i++) {
cin >> a;
f[a] = 1;
}
l = 1;
for (i = 0; i <= n; i++) {
if (f[i] == f[i + 1])
f[i] = 0;
else {
f[i] = l;
l++;
}
}
for (i = 0; i < k; i++) {
cin >> g[i];
}
memset(gr, ~0, sizeof gr);
for (i = 0; i <= n; i++) {
if (f[i]) {
q.push({0, i});
}
while (q.size()) {
a = -q.front().first;
s = q.front().second;
q.pop();
if (fx[s] == f[i]) continue;
fx[s] = f[i];
if (f[s]) {
gr[f[i]][f[s]] = a;
gr[f[s]][f[i]] = a;
}
for (int j = 0; j < k; j++) {
if (s + g[j] <= n && fx[s + g[j]] != f[i]) {
q.push({-a - 1, s + g[j]});
}
if (s - g[j] >= 0 && fx[s - g[j]] != f[i]) q.push({-a - 1, s - g[j]});
}
}
}
memset(d, ~0, sizeof d);
d[(1 << (l - 1)) - 1] = 0;
for (i = (1 << (l - 1)) - 1; i > 0; i--) {
if (d[i] == -1) continue;
j = -1;
for (a = 1; a < l; a++) {
if ((i & (1 << (a - 1)))) {
if (j == -1) j = a;
} else
continue;
if (j == a) continue;
if (gr[a][j] == -1) continue;
h = (i ^ ((1 << (a - 1)) | (1 << (j - 1))));
if (d[h] == -1 || d[h] > d[i] + gr[a][j]) d[h] = d[i] + gr[a][j];
}
}
cout << d[0];
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10010;
const int MAXL = 110;
const int MAXK = 31;
const int MAXM = 1 << 21;
const int INF = 1000000000;
int pos[MAXK], xtot;
int ai[MAXL];
int n, k, L;
int g[MAXK][MAXK];
int f[MAXM];
queue<int> que;
int dist[MAXN];
bool vis[MAXN];
void init() {
scanf("%d%d%d", &n, &k, &L);
xtot = 0;
int tmp[MAXK];
for (int i = 0; i < k; ++i) scanf("%d", &tmp[i]);
for (int i = 0; i < k; ++i) {
if (i == 0 || tmp[i - 1] + 1 != tmp[i]) pos[xtot++] = tmp[i] - 1;
if (i == k - 1 || tmp[i + 1] - 1 != tmp[i]) pos[xtot++] = tmp[i];
}
for (int i = 0; i < L; ++i) scanf("%d", &ai[i]);
}
void updata(int x, int y) {
if (dist[x] + 1 < dist[y]) {
dist[y] = dist[x] + 1;
if (!vis[y]) que.push(y);
vis[y] = 1;
}
}
void g_cal(int st) {
que.push(pos[st]);
for (int i = 0; i <= n; ++i) dist[i] = INF;
dist[pos[st]] = 0;
for (int i = 0; i <= n; ++i) vis[i] = 0;
vis[pos[st]] = 1;
for (int x; !que.empty();) {
x = que.front();
que.pop();
for (int i = 0; i < L; ++i) {
if (x + ai[i] <= n) updata(x, x + ai[i]);
if (0 <= x - ai[i]) updata(x, x - ai[i]);
}
vis[x] = 0;
}
for (int i = 0; i < xtot; ++i) g[st][i] = dist[pos[i]];
}
void solve() {
for (int i = 0; i < xtot; ++i) g_cal(i);
f[0] = 0;
int limit = 1 << xtot;
for (int i, j, sta = 1; sta < limit; ++sta) {
f[sta] = INF;
for (i = 0; (sta & (1 << i)) == 0; ++i)
;
for (j = i + 1; j < xtot; ++j)
if (sta & (1 << j))
f[sta] = min(f[sta], f[sta ^ (1 << i) ^ (1 << j)] + g[i][j]);
}
if (f[limit - 1] < INF)
printf("%d\n", f[limit - 1]);
else
puts("-1");
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Inf = 1000000000;
const int Maxn = 10005;
const int Maxk = 12;
const int Maxl = 105;
const int MaxN = 1 << 20;
int n, k, l;
int x[Maxn];
int a[Maxl];
vector<int> V;
int dist[2 * Maxk][Maxn];
int dp[MaxN];
void BFS(int ind, int st) {
fill(dist[ind], dist[ind] + Maxn, Inf);
dist[ind][st] = 0;
queue<int> Q;
Q.push(st);
while (!Q.empty()) {
int v = Q.front(), d = dist[ind][v];
Q.pop();
for (int i = 0; i < l; i++) {
int u = v + a[i];
if (u <= n && d + 1 < dist[ind][u]) {
dist[ind][u] = d + 1;
Q.push(u);
}
u = v - a[i];
if (u >= 0 && d + 1 < dist[ind][u]) {
dist[ind][u] = d + 1;
Q.push(u);
}
}
}
}
int main() {
scanf("%d %d %d", &n, &k, &l);
while (k--) {
int onx;
scanf("%d", &onx);
x[onx] = 1;
}
for (int i = 0; i < l; i++) scanf("%d", &a[i]);
for (int i = 0; i <= n; i++)
if (x[i] != x[i + 1]) {
V.push_back(i);
BFS(V.size() - 1, i);
}
int N = V.size();
fill(dp, dp + (1 << N), Inf);
dp[0] = 0;
for (int i = 0; i < (1 << N) - 1; i++) {
int j = N - 1;
while (i & 1 << j) j--;
for (int k = j - 1; k >= 0; k--)
dp[i ^ 1 << k ^ 1 << j] =
min(dp[i ^ 1 << k ^ 1 << j], dp[i] + dist[k][V[j]]);
}
int resin = (1 << N) - 1;
printf("%d\n", dp[resin] == Inf ? -1 : dp[resin]);
return 0;
}
|
#include <bits/stdc++.h>
void Get(int &T) {
char C;
bool F = 0;
for (; C = getchar(), C < '0' || C > '9';)
if (C == '-') F = 1;
for (T = C - '0'; C = getchar(), C >= '0' && C <= '9'; T = T * 10 + C - '0')
;
F && (T = -T);
}
int N, K, L;
int A[10005];
int Pos[25];
struct E {
int V, Next;
} Edge[2500005];
int EdgeTop;
int Head[10005];
void Add(int U, int V) {
Edge[++EdgeTop] = (E){V, Head[U]};
Head[U] = EdgeTop;
}
void Init() {
int X;
Get(N);
Get(K);
Get(L);
for (int i = 1; i <= K; i++) {
Get(X);
A[X] = 1;
}
N++;
for (int i = N; i >= 1; i--) {
A[i] = (A[i] != A[i - 1]);
}
K = 0;
for (int i = 1; i <= N; i++) {
if (A[i] == 1) {
K++;
Pos[K] = i;
}
}
for (int k = 1, W; k <= L; k++) {
Get(W);
for (int i = 1, j = W + 1; j <= N; i++, j++) {
Add(i, j);
Add(j, i);
}
}
}
int F[10005];
int Visited[10005];
int Queue[15005];
void SPFA(int X) {
memset(F, 0x2f, sizeof F);
int L, R;
Queue[L = R = 1] = X;
F[X] = 0;
Visited[X] = 1;
for (;;) {
for (int i = Head[Queue[L]]; i; i = Edge[i].Next) {
if (F[Edge[i].V] > F[Queue[L]] + 1) {
F[Edge[i].V] = F[Queue[L]] + 1;
if (!Visited[Edge[i].V]) {
Visited[Edge[i].V] = 1;
R++;
if (R > 15000) R = 1;
Queue[R] = Edge[i].V;
}
}
}
Visited[Queue[L]] = 0;
if (L == R) break;
L++;
if (L > 15000) L = 1;
}
}
int W[25][25];
int G[1048605];
int DP(int i) {
if (G[i] != -1) return G[i];
G[i] = 0x2f2f2f2f;
int Min = 0;
for (int k = K; k >= 1; k--) {
if ((((i) >> (k - 1)) & 1)) Min = k;
}
for (int k = K; k >= 1; k--)
if (((((i) >> (k - 1)) & 1)) && k != Min) {
int Ans0 = DP(i & ~((1) << (k - 1)) & ~((1) << (Min - 1))) + W[Min][k];
if (G[i] > Ans0) G[i] = Ans0;
}
return G[i];
}
int Ans;
void Work() {
for (int k = 1; k <= K; k++) {
SPFA(Pos[k]);
for (int p = 1; p <= K; p++) W[k][p] = F[Pos[p]];
}
memset(G, 0xff, sizeof G);
G[0] = 0;
Ans = DP((1 << K) - 1);
}
void Output() {
if (Ans >= 0x2f2f2f2f)
puts("-1");
else
printf("%d\n", Ans);
}
int main() {
Init();
Work();
Output();
return 0;
}
|
#include <bits/stdc++.h>
inline int getint() {
int x = 0, p = 1;
char c = getchar();
while (c <= 32) c = getchar();
if (c == 45) p = -p, c = getchar();
while (c > 32) x = x * 10 + c - 48, c = getchar();
return x * p;
}
using namespace std;
const int N = 10010;
const int SS = (1 << 21) + 10;
bool ok[N];
int n, m, k, X[N], a[N];
int dp[SS], dis[25][N];
vector<int> v;
queue<int> qu;
inline bool isvalid(int x) {
if (x <= 0 || x > n + 1) return false;
return true;
}
void init() {
for (int(iii) = 0; (iii) < (v.size()); (iii)++) {
int S = v[iii];
for (int i = 1; i <= n + 1; i++) dis[iii][i] = 1000000000;
dis[iii][S] = 0;
qu.push(S);
while (!qu.empty()) {
int u = qu.front();
qu.pop();
for (int(i) = 0; (i) < (k); (i)++) {
int fx = u - a[i];
if (isvalid(fx) && dis[iii][fx] == 1000000000) {
dis[iii][fx] = dis[iii][u] + 1;
qu.push(fx);
}
fx = u + a[i];
if (isvalid(fx) && dis[iii][fx] == 1000000000) {
dis[iii][fx] = dis[iii][u] + 1;
qu.push(fx);
}
}
}
}
}
int go(int mask) {
if (dp[mask] >= 0) return dp[mask];
int ans = 1000000000;
for (int(i) = 0; (i) < (v.size()); (i)++)
if (mask & (1 << i)) {
for (int j = i + 1; j < v.size(); j++)
if (mask & (1 << j)) {
if (dis[i][v[j]] < 1000000000) {
ans = min(ans, dis[i][v[j]] + go(mask ^ (1 << i) ^ (1 << j)));
}
}
break;
}
return dp[mask] = ans;
}
int main() {
n = getint();
m = getint();
k = getint();
for (int(i) = 0; (i) < (m); (i)++) {
int x = getint();
ok[x] = true;
}
for (int i = 1; i <= n + 1; i++)
if (ok[i] != ok[i - 1]) v.push_back(i);
for (int(i) = 0; (i) < (k); (i)++) a[i] = getint();
init();
memset(dp, -1, sizeof(dp));
dp[0] = 0;
int res = go((1 << v.size()) - 1);
if (res == 1000000000) res = -1;
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10086;
const int INF = 0x3f3f3f3f;
int dp[1 << 20], w[20][20];
int d[MAXN];
int x[20], a[100];
inline int rightZeroBit(int mask) {
for (int i = 0;; i++) {
if ((mask & (1 << i)) == 0) {
return i;
}
}
return -1;
}
int main() {
int n, k, l;
for (; ~scanf("%d%d%d", &n, &k, &l);) {
for (int i = 0; i < k; i++) {
scanf("%d", &x[i]);
}
sort(x, x + k);
k = unique(x, x + k) - x;
for (int i = 0; i < l; i++) {
scanf("%d", &a[i]);
}
sort(a, a + l);
l = unique(a, a + l) - a;
set<int> iset;
for (int i = 0; i < k; i++) {
pair<set<int>::iterator, bool> p;
p = iset.insert(x[i] - 1);
if (!p.second) {
iset.erase(p.first);
}
p = iset.insert(x[i]);
if (!p.second) {
iset.erase(p.first);
}
}
k = copy(iset.begin(), iset.end(), x) - x;
for (int i = 0; i < k; i++) {
fill(d, d + n + 1, INF);
d[x[i]] = 0;
priority_queue<pair<int, int> > pq;
pq.push(make_pair(0, x[i]));
while (!pq.empty()) {
int s = pq.top().second;
int t = -pq.top().first;
pq.pop();
if (d[s] != t) {
continue;
}
for (int j = 0; j < l; j++) {
if (s - a[j] >= 0 && d[s - a[j]] > t + 1) {
d[s - a[j]] = t + 1;
pq.push(make_pair(-d[s - a[j]], s - a[j]));
}
if (s + a[j] <= n && d[s + a[j]] > t + 1) {
d[s + a[j]] = t + 1;
pq.push(make_pair(-d[s + a[j]], s + a[j]));
}
}
}
for (int j = 0; j < k; j++) {
w[i][j] = d[x[j]];
}
}
fill(dp, dp + (1 << k), INF);
dp[0] = 0;
for (int mask = 0; mask < (1 << k); mask++) {
int u = rightZeroBit(mask);
if (u >= k) {
continue;
}
for (int v = 0; v < k; v++) {
if ((mask & (1 << v)) == 0) {
int _mask = mask ^ (1 << u) ^ (1 << v);
dp[_mask] = min(dp[_mask], dp[mask] + w[u][v]);
}
}
}
printf("%d\n", dp[(1 << k) - 1] == INF ? -1 : dp[(1 << k) - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int iinf = 1e9 + 7;
const long long linf = 1ll << 60;
const double dinf = 1e10;
template <typename T>
inline void scf(T &x) {
bool f = 0;
x = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') {
f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
if (f) x = -x;
return;
}
template <typename T1, typename T2>
void scf(T1 &x, T2 &y) {
scf(x);
return scf(y);
}
template <typename T1, typename T2, typename T3>
void scf(T1 &x, T2 &y, T3 &z) {
scf(x);
scf(y);
return scf(z);
}
const int N = 1e4 + 100;
const int M = (1 << 20) + 100;
int n, m, k;
int dst[N];
int dp[M];
int opr[110];
bool a[N];
vector<int> pos;
int q[N];
int d[30][30];
int msk[30];
void BFS(int S) {
int fnt, rar;
fnt = rar = 0;
q[rar++] = S;
memset(dst, -1, sizeof(dst));
dst[S] = 0;
while (fnt != rar) {
int u = q[fnt++];
for (int i = 0; i < (k); i++) {
int v = u + opr[i];
if (v >= 1 && v <= n && dst[v] < 0) dst[v] = dst[u] + 1, q[rar++] = v;
v = u - opr[i];
if (v >= 1 && v <= n && dst[v] < 0) dst[v] = dst[u] + 1, q[rar++] = v;
}
}
return;
}
inline void update(int &x, const int &y) {
if (x == -1 || y < x) x = y;
return;
}
int main() {
scf(n, m, k);
n++;
for (int i = (1); i <= (m); i++) {
int x;
scf(x);
a[x] = 1;
}
for (int i = 0; i < (k); i++) scf(opr[i]);
for (int i = (1); i <= (n); i++)
if (a[i] != a[i - 1]) pos.push_back(i);
m = (int)pos.size();
for (int i = 0; i < (m); i++) msk[i] = 1 << i;
for (int i = 0; i < (m); i++) {
BFS(pos[i]);
for (int j = 0; j < (m); j++) d[i][j] = dst[pos[j]];
}
int MASK = 1 << m;
memset(dp, -1, sizeof(dp));
dp[0] = 0;
for (int i = 0; i < (MASK); i++)
if (dp[i] >= 0) {
for (int u = 0; u < (m); u++)
if (!(msk[u] & i))
for (int v = (u + 1); v <= (m - 1); v++)
if (!(msk[v] & i) && d[u][v] != -1) {
int mask = i | msk[u] | msk[v];
update(dp[mask], dp[i] + d[u][v]);
}
}
printf("%d\n", dp[MASK - 1]);
return 0;
}
|
#include <bits/stdc++.h>
int n, k, l, x, t, p, c[10100], d[10100], q[10100], a[10100], g[30][10100],
h[10100], f[2000000];
int main() {
scanf("%d%d%d", &n, &k, &l);
for (int i = 0; i < k; i++) scanf("%d", &x), c[x] = 1;
for (int i = 0; i < l; i++) scanf("%d", a + i);
for (int i = 0; i < n + 1; i++)
if (c[i] ^= c[i + 1]) {
memset(d, 0, sizeof(d));
q[(t = 1) - 1] = i;
d[i] = 1;
for (int j = 0; j < t; j++)
for (int k = 0; k < l; k++) {
if (q[j] >= a[k] && !d[q[j] - a[k]])
d[q[t++] = q[j] - a[k]] = d[q[j]] + 1;
if (q[j] + a[k] <= n && !d[q[j] + a[k]])
d[q[t++] = q[j] + a[k]] = d[q[j]] + 1;
}
for (int j = 0; j < n + 1; j++) g[p][j] = d[j] ? d[j] - 1 : 0x30303030;
h[p++] = i;
}
memset(f, 0x30, sizeof(f));
f[0] = 0;
for (int i = 0; i < (1 << p); i++)
for (int j = 0; j < p; j++)
if ((~i >> j) & 1)
for (int k = j + 1; k < p; k++)
if ((~i >> k) & 1)
f[i | (1 << j) | (1 << k)] =
std::min(f[i | (1 << j) | (1 << k)], f[i] + g[j][h[k]]);
printf("%d\n", f[(1 << p) - 1] < 100000000 ? f[(1 << p) - 1] : -1);
}
|
#include <bits/stdc++.h>
using namespace std;
bool vis[40010];
int N, M, K, num[110], cnt[20], minDis[40010], minN[31][31], dp[1 << 21 + 1],
cnt1[1 << 21 + 1];
queue<int> q;
inline void Dijk(int dir) {
memset(minDis, 0x3f, sizeof(minDis));
minDis[cnt[dir]] = 0;
q.push(cnt[dir]);
while (!q.empty()) {
int t = q.front();
q.pop();
for (int i = 1; i <= K; i++) {
if (t + num[i] <= N + 1 && minDis[t + num[i]] > minDis[t] + 1) {
minDis[t + num[i]] = minDis[t] + 1;
q.push(t + num[i]);
}
if (t - num[i] > 0 && minDis[t - num[i]] > minDis[t] + 1) {
minDis[t - num[i]] = minDis[t] + 1;
q.push(t - num[i]);
}
}
}
for (int i = 1; i <= cnt[0]; i++) minN[dir][i] = minDis[cnt[i]];
}
int main() {
cin >> N >> M >> K;
for (int i = 1; i <= M; i++) {
int a;
cin >> a;
vis[a] = 1;
}
for (int i = 1; i <= N + 1; i++)
if (vis[i] ^ vis[i - 1]) cnt[++cnt[0]] = i;
if (cnt[0] == 0) {
cout << 0;
return 0;
}
for (int i = 1; i <= K; i++) cin >> num[i];
for (int i = 1; i <= cnt[0]; i++) Dijk(i);
for (int i = 1; i < 1 << cnt[0]; i++) cnt1[i] = cnt1[i - (i & -i)] + 1;
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for (int i = 0; i < (1 << cnt[0]); i++)
if (!(cnt1[i] & 1)) {
int t = ((1 << cnt[0]) - 1) ^ i;
if (t == 0) {
cout << (dp[i] == 0x3f3f3f3f ? -1 : dp[i]);
return 0;
}
t = log2(t & -t) + 1;
for (int j = t + 1; j <= cnt[0]; j++)
if (!(i & (1 << j - 1)))
dp[i | (1 << t - 1) | (1 << j - 1)] =
min(dp[i | (1 << t - 1) | (1 << j - 1)], dp[i] + minN[t][j]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int m, k, l, n;
int x[22], a[110];
int f[(1 << 20)];
int que[10010], dis[10010], g[22][22];
int pos[22];
bool inq[10010];
int head, tail;
bool tag[10010];
void input() {
memset(tag, 0, sizeof(tag));
for (int i = 1; i <= k; i++) {
scanf("%d", x + i);
tag[x[i]] = true;
}
for (int i = 1; i <= l; i++) scanf("%d", a + i);
n = 0;
for (int i = 0; i <= m; i++)
if (tag[i] != tag[i + 1]) pos[n++] = i;
}
void update(int curx, int nextx) {
if (dis[curx] + 1 < dis[nextx] || dis[nextx] == -1) {
dis[nextx] = dis[curx] + 1;
if (!inq[nextx])
que[tail] = nextx, inq[nextx] = true, tail = (tail + 1) % 10010;
}
}
void cal_path() {
for (int i = 0; i < n; i++) {
memset(dis, -1, sizeof(dis));
memset(inq, 0, sizeof(inq));
que[0] = pos[i];
dis[pos[i]] = 0;
for (head = 0, tail = 1; head != tail; head = (head + 1) % 10010) {
int curx = que[head];
for (int j = 1; j <= l; j++) {
if (curx - a[j] >= 0) update(curx, curx - a[j]);
if (curx + a[j] <= m) update(curx, curx + a[j]);
}
inq[curx] = false;
}
for (int j = 0; j < n; j++) g[i][j] = dis[pos[j]];
}
}
void dp() {
memset(f, 255, sizeof(f));
f[0] = 0;
for (int i = 0; i < 1 << n; i++)
if (f[i] != -1) {
int j;
for (j = 0; j < n && (i & (1 << j)); j++)
;
for (int k = j + 1; k < n; k++)
if ((i & (1 << k)) == 0 && g[j][k] != -1) {
int v = i | (1 << j) | (1 << k);
if (f[i] + g[j][k] < f[v] || f[v] == -1) f[v] = f[i] + g[j][k];
}
}
printf("%d\n", f[(1 << n) - 1]);
}
int main() {
while (scanf("%d%d%d", &m, &k, &l) != EOF) {
input();
cal_path();
dp();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
inline void write(int x) {
static int sta[35];
int top = 0;
do {
sta[++top] = x % 10, x /= 10;
} while (x);
while (top) putchar(sta[top--] + '0');
return;
}
int n, K, m, cnt = -1, ans;
int a[1000000], b[1000000], flg[1000000], f[1000000];
int dis[100][100], d[1000000];
queue<int> q;
inline void bfs(int x) {
for (int i = 1; i <= n + 1; i++) d[i] = 0x3f3f3f3f;
d[x] = 0;
q.push(x);
while (!q.empty()) {
int p = q.front();
q.pop();
for (int i = 1; i <= m; i++) {
int y = p + b[i];
if (y <= n + 1 && d[y] == 0x3f3f3f3f) d[y] = d[p] + 1, q.push(y);
y = p - b[i];
if (y >= 1 && d[y] == 0x3f3f3f3f) d[y] = d[p] + 1, q.push(y);
}
}
for (int i = 1; i <= n + 1; i++)
if (flg[i] != -1) dis[flg[i]][flg[x]] = dis[flg[x]][flg[i]] = d[i];
}
int main() {
n = read(), K = read(), m = read();
for (int i = 1; i <= K; i++) a[read()] = 1;
for (int i = 1; i <= m; i++) b[i] = read();
for (int i = n + 1; i; i--) a[i] ^= a[i - 1];
for (int i = 1; i <= n + 1; i++) flg[i] = (a[i]) ? ++cnt : -1;
for (int i = 1; i <= n + 1; i++)
if (a[i]) bfs(i);
for (int i = 1; i < (1 << (cnt + 1)); i++) f[i] = 0x3f3f3f3f;
for (int i = 0; i < (1 << (cnt + 1)); i++) {
if (f[i] == 0x3f3f3f3f) continue;
for (int j = 0; j <= cnt; j++) {
if (i >> j & 1) continue;
for (int k = j + 1; k <= cnt; k++) {
if (i >> k & 1) continue;
f[i + (1 << j) + (1 << k)] =
min(f[i + (1 << j) + (1 << k)], f[i] + dis[j][k]);
}
}
}
int ans = f[(1 << (cnt + 1)) - 1];
if (ans == 0x3f3f3f3f)
printf("-1\n");
else
printf("%d\n", f[(1 << (cnt + 1)) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
bool debug = false;
int l;
int ks[25];
set<int> a;
int dis[10005];
long long dp[1 << 20], mp[22][22];
void bfs(int x) {
for (int i = 0; i <= n; i++) dis[i] = 2147483647;
queue<int> q;
q.push(x);
dis[x] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int aa : a) {
if (u + aa <= n && dis[u + aa] > dis[u] + 1) {
dis[u + aa] = dis[u] + 1;
q.push(u + aa);
}
if (u - aa >= 0 && dis[u - aa] > dis[u] + 1) {
dis[u - aa] = dis[u] + 1;
q.push(u - aa);
}
}
}
}
int main() {
scanf("%d%d%d", &n, &k, &l);
int x;
for (int i = 0; i < k; i++) {
scanf("%d", ks + i);
ks[i]--;
ks[k + i] = ks[i] + 1;
}
for (int i = 0; i < l; i++) {
scanf("%d", &x);
a.insert(x);
}
k *= 2;
for (int i = 0; i < k; i++) {
bfs(ks[i]);
for (int j = 0; j < k; j++) mp[i][j] = dis[ks[j]];
}
for (int i = 1; i < (1 << k); i++) {
dp[i] = 2147483647;
}
for (int ma = 1; ma < (1 << k); ma++) {
int i = 0;
for (i = 0; i < k; i++)
if ((ma >> i) & 1) break;
for (int j = 0; j < k; j++)
if (j != i && ((ma >> j) & 1)) {
if (mp[i][j] < 0) {
cout << i << j << endl;
}
dp[ma] = min(dp[ma], dp[ma ^ (1 << i) ^ (1 << j)] + mp[i][j]);
}
}
if (dp[(1 << k) - 1] == 2147483647)
puts("-1");
else
printf("%d\n", dp[(1 << k) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 7, K = 23, L = 105;
const int inf = 1e9 + 7;
int n, k, l;
int dist[K][K];
int a[N], pos[N], len[L];
int f[1 << K];
int q[N], step[N], st, ed;
bool used[N];
void getdis(int begin) {
memset(used, false, sizeof(used));
for (int i = 0; i < k; i++) dist[begin][i] = inf;
st = 0, ed = 1, q[ed] = pos[begin];
step[ed] = 0, used[q[ed]] = true;
while (st != ed) {
int u = q[++st];
for (int i = 0; i < l; i++) {
int v = u + len[i];
if (v <= n + 1 && !used[v]) {
q[++ed] = v;
step[ed] = step[st] + 1;
used[v] = true;
if (a[v] != -1) dist[begin][a[v]] = step[ed];
}
v = u - len[i];
if (v > 0 && !used[v]) {
q[++ed] = v;
step[ed] = step[st] + 1;
used[v] = true;
if (a[v] != -1) dist[begin][a[v]] = step[ed];
}
}
}
}
int main() {
scanf("%d%d%d", &n, &k, &l);
memset(a, -1, sizeof(a));
for (int i = 0; i < k; i++) {
int p;
scanf("%d", &p);
a[p] = 1;
}
for (int i = 0; i < l; i++) scanf("%d", len + i);
k = 0;
for (int i = n + 1; i > 0; i--) {
a[i] = (a[i] == a[i - 1] ? -1 : 1);
if (a[i] == 1) {
a[i] = k;
pos[k] = i;
++k;
}
}
for (int i = 0; i < k; i++) getdis(i);
f[0] = 0;
for (int comb = 1; comb < 1 << k; ++comb) {
int x = 0;
f[comb] = inf;
while (!((comb >> x) & 1)) ++x;
for (int i = 0; i < k; i++) {
if ((x == i) || !((comb >> i) & 1) || dist[x][i] == inf) continue;
int ncomb = comb ^ (1 << i) ^ (1 << x);
if (f[ncomb] == inf) continue;
f[comb] = min(f[comb], f[ncomb] + dist[x][i]);
}
}
if (f[(1 << k) - 1] == inf)
puts("-1");
else
printf("%d\n", f[(1 << k) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int m, n, l, tmt[10010], len[110], w[20][20], dis[10010], lst[20], dp[1 << 20];
void BFS(int idx, int p) {
queue<int> q;
for (int i = 0; i <= n; i++) dis[i] = 999999999;
dis[p] = 0;
q.push(p);
while (!q.empty()) {
p = q.front();
q.pop();
for (int i = 0; i < l; i++)
for (int j = -1; j <= 1; j += 2) {
int t = p + j * len[i];
if (t < 0 || t > n || dis[p] + 1 >= dis[t]) continue;
dis[t] = dis[p] + 1;
q.push(t);
}
}
for (int i = 0; i < m; i++) w[idx][i] = dis[lst[i]];
}
int main() {
int k, i, x, y;
scanf("%d%d%d", &n, &k, &l);
for (i = 0; i < k; i++) {
scanf("%d", &x);
tmt[x - 1] ^= 1;
tmt[x] ^= 1;
}
for (i = 0; i < l; i++) scanf("%d", len + i);
for (i = 0; i <= n; i++)
if (tmt[i]) lst[m++] = i;
for (i = 0; i < m; i++) BFS(i, lst[i]);
for (i = 1; i < (1 << m); i++) {
dp[i] = 999999999;
for (x = 0; x < m && !((i >> x) & 1); x++)
;
for (y = x + 1; y < m; y++) {
if (!((i >> y) & 1)) continue;
dp[i] = min(dp[i], dp[i - (1 << x) - (1 << y)] + w[x][y]);
}
}
if (dp[(1 << m) - 1] == 999999999)
puts("-1");
else
printf("%d\n", dp[(1 << m) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 100000000;
int d[1 << 21];
bool flag[1 << 21];
int que[1000000];
int x[25], a[105], b[10005];
int A[10005], B[10005];
int n, m, k, cnt, num;
int dist[25][10005];
int L[25], R[25];
int main() {
scanf("%d%d%d", &n, &m, &k);
int mode = 0;
for (int i = 0, prev = 0, now; i < m; i++) {
scanf("%d", &now);
if (now - 1 > prev) x[cnt++] = now - 1 - prev, mode *= 2;
x[cnt++] = 1;
mode = mode * 2 + 1;
prev = now;
if (i == m - 1 && prev < n) x[cnt++] = n - prev, mode *= 2;
}
for (int i = 0; i < cnt / 2; i++) swap(x[i], x[cnt - 1 - i]);
x[cnt] = 1;
for (int i = 0, s = 0; i <= cnt; s += x[i++]) L[i] = s + 1, R[i] = s + x[i];
for (int i = 0; i < k; i++) scanf("%d", &a[i]);
for (int i = 0; i < cnt; i++) {
for (int j = 1; j <= n + 1; j++) dist[i][j] = oo;
dist[i][L[i]] = 0;
que[0] = L[i];
for (int l = 0, r = 0; l <= r; l++)
for (int j = 0; j < k; j++) {
if (que[l] + a[j] <= n + 1 && dist[i][que[l] + a[j]] == oo) {
que[++r] = que[l] + a[j];
dist[i][que[r]] = dist[i][que[l]] + 1;
}
if (que[l] - a[j] > 0 && dist[i][que[l] - a[j]] == oo) {
que[++r] = que[l] - a[j];
dist[i][que[r]] = dist[i][que[l]] + 1;
}
}
}
for (int i = 0; i < (1 << cnt); i++) d[i] = oo;
d[0] = 0;
flag[0] = 1;
que[0] = 0;
int r = 0;
for (int l = 0; l <= r; flag[que[l++]] = 0)
if (d[que[l]] + 1 < d[mode]) {
int now = que[l], v = d[que[l]];
for (int i = 0, ss = 0; i < cnt; i++) {
ss += x[i];
if (!((mode & (1 << i)) ^ (now & (1 << i)))) continue;
int tmp = 0;
for (int j = i; j < cnt; ss += x[++j]) {
tmp += (1 << j);
if (d[now ^ tmp] > v + dist[i][ss + 1]) {
d[now ^ tmp] = v + dist[i][ss + 1];
if (!flag[now ^ tmp]) {
que[++r] = now ^ tmp;
flag[que[r]] = 1;
}
}
}
break;
}
}
if (d[mode] == oo)
printf("-1\n");
else
printf("%d\n", d[mode]);
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1>
void print_list(const T1& a) {
cerr << a << endl;
}
template <typename T1, typename T2>
void print_list(const T1& a, const T2& b) {
cerr << a << " " << b << endl;
}
template <typename T1, typename T2, typename T3>
void print_list(const T1& a, const T2& b, const T3& c) {
cerr << a << " " << b << " " << c << endl;
}
template <typename T1, typename T2, typename T3, typename T4>
void print_list(const T1& a, const T2& b, const T3& c, const T4& d) {
cerr << a << " " << b << " " << c << " " << d << endl;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5>
void print_list(const T1& a, const T2& b, const T3& c, const T4& d,
const T5& e) {
cerr << a << " " << b << " " << c << " " << d << " " << e << endl;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6>
void print_list(const T1& a, const T2& b, const T3& c, const T4& d, const T5& e,
const T6& f) {
cerr << a << " " << b << " " << c << " " << d << " " << e << " " << f << endl;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7>
void print_list(const T1& a, const T2& b, const T3& c, const T4& d, const T5& e,
const T6& f, const T7& g) {
cerr << a << " " << b << " " << c << " " << d << " " << e << " " << f << " "
<< g << endl;
}
template <typename A, typename B>
ostream& operator<<(ostream& out, const pair<A, B>& pp) {
out << "(" << pp.first << "," << pp.second << ")";
return out;
}
template <typename A, typename B>
istream& operator<<(istream& in, pair<A, B>& pp) {
cerr << "A pair wanted" << endl;
in >> pp.first >> pp.second;
return in;
}
template <typename T>
ostream& operator<<(ostream& out, const vector<T>& vect) {
out << "length = " << vect.size() << endl;
for (int i = 0; i < vect.size(); i++) out << vect[i] << " ";
out << endl;
return out;
}
template <typename T>
istream& operator>>(istream& in, vector<T>& vect) {
vect.clear();
int n;
cerr << "A integer of length wanted" << endl;
in >> n;
vect.resize(n);
cerr << n << " elements wanted" << endl;
for (int i = 0; i < n; i++) in >> vect[i];
return in;
}
template <typename T>
ostream& operator<<(ostream& out, const vector<vector<T> >& vect) {
out << "row number=" << vect.size() << endl;
for (int i = 0; i < vect.size(); i++) {
out << "row #" << i << ":";
for (int j = 0; j < vect[i].size(); j++) out << " " << vect[i][j];
out << endl;
}
return out;
}
template <typename T>
istream& operator>>(istream& in, vector<vector<T> >& vect) {
vect.clear();
int n, m;
cerr << "Two integers wnated" << endl;
in >> n >> m;
vect.resize(n);
cerr << "A matrix " << n << " X " << m << " wanted" << endl;
for (int i = 0; i < n; i++) {
vect[i].resize(m);
for (int j = 0; j < m; j++) in >> vect[i][j];
}
return in;
}
template <typename T>
inline void updateMax(T& a, const T& b) {
a = max(a, b);
}
template <typename T>
inline void updateMin(T& a, const T& b) {
a = min(a, b);
}
template <typename T>
inline vector<T> erase(vector<T> table, int ind) {
assert(ind < table.size());
table.erase(table.begin() + ind);
return table;
}
template <typename T>
vector<T> unique(vector<T> table) {
sort(table.begin(), table.end());
return vector<T>(table.begin(), unique(table.begin(), table.end()));
}
template <class T>
vector<T> parse(const string& ss, const char* cut = " ") {
vector<T> re;
for (int j = 0; j < ss.size(); j++) {
string s;
while (j < ss.size() && NULL == strchr(cut, ss[j])) s += ss[j++];
if (!s.empty()) {
T tmp;
istringstream is(s);
is >> tmp;
re.push_back(tmp);
}
}
return re;
}
int countBit(int n) {
int re = 0;
while (n) re++, n ^= ((((n) ^ ((n)-1)) & n));
return re;
}
int MSB(int n) {
if (n == 0) return 0;
while (((((n) ^ ((n)-1)) & n)) != n) n ^= ((((n) ^ ((n)-1)) & n));
return n;
}
void initHash(int n, int hash[]) {
for (int i = 0; i < n; i++) hash[((1) << (i))] = i;
}
void initBcnt(int n, int bcnt[]) {
bcnt[0] = 0;
for (int i = 1; i < ((1) << (n)); i++)
bcnt[i] = bcnt[i ^ ((((i) ^ ((i)-1)) & i))] + 1;
}
template <typename T>
T __gcd(T n, T m, T& a, T& b) {
T a1 = 0, b1 = 1;
a = 1, b = 0;
while (m) {
T c = n / m;
T r = n - m * c;
T t;
t = a;
a = a1;
a1 = t - c * a1;
t = b;
b = b1;
b1 = t - c * b1;
n = m;
m = r;
}
return n;
}
struct Node {
int r, c, d;
int v;
Node(int x, int y, int z, int v1) : r(x), c(y), d(z), v(v1){};
bool operator<(const Node& other) const { return v > other.v; };
};
const int dir[][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1},
{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
const char dname[] = "NWSE";
template <int S, bool (*cmpLess)(int, int)>
class binaryHeap {
int heap[S], hpos[S];
int hs;
public:
binaryHeap<S, cmpLess>() { hs = 0; };
void adjustUp(int key) {
int pos = hpos[key];
assert(pos >= 0 && pos < hs);
assert(heap[pos] == key);
while (pos && cmpLess(key, heap[(pos - 1) >> 1])) {
heap[pos] = heap[(pos - 1) >> 1];
hpos[heap[pos]] = pos;
pos = (pos - 1) >> 1;
}
heap[pos] = key;
hpos[key] = pos;
}
void adjustDown(int key) {
int pos = hpos[key], mm;
assert(pos >= 0 && pos < hs);
assert(heap[pos] == key);
while ((pos << 1) + 1 < hs) {
mm = 1 + (pos << 1);
if (mm + 1 < hs && cmpLess(heap[mm + 1], heap[mm])) mm++;
if (cmpLess(key, heap[mm])) break;
heap[pos] = heap[mm];
hpos[heap[pos]] = pos;
pos = mm;
}
heap[pos] = key;
hpos[key] = pos;
}
int popHeap() {
int re = heap[0];
hs--;
if (hs) {
heap[0] = heap[hs];
hpos[heap[0]] = 0;
adjustDown(heap[0]);
}
return re;
}
void removeHeap(int key) {
int pos = hpos[key];
assert(pos >= 0 && pos < hs);
assert(heap[pos] == key);
heap[pos] = heap[hs - 1];
hpos[heap[pos]] = pos;
hs--;
if (hs) {
adjustUp(heap[pos]);
adjustDown(heap[pos]);
}
}
void pushHeap(int key) {
heap[hs] = key;
hpos[key] = hs;
hs++;
adjustUp(key);
}
int size() { return hs; };
void clear() { hs = 0; };
};
const int N = 1 << 21;
int dis[N];
bool cmp(int a, int b) { return dis[a] < dis[b]; }
binaryHeap<N, cmp> heap;
int dp[10001];
int block[100], light[100];
int aa[100000], bb[100000], cc[100000], mk[100000];
int stick[100];
int edge[100][100], bits[100][100];
int main() {
int n, k, m;
cin >> n >> k >> m;
int pre = -1;
int top = 0;
int des = 0;
for (int i = 0; i < k; i++) {
int x;
scanf("%d", &x);
x--;
light[i] = x;
if (x - pre - 1 > 0) block[top++] = x - pre - 1;
des ^= ((1) << (top));
block[top++] = 1;
pre = x;
}
if (pre < n - 1) block[top++] = n - 1 - pre;
const int inf = 1000000000;
dp[0] = 0;
for (int i = 1; i <= n; i++) dp[i] = inf;
for (int i = 0; i < m; i++) {
int x;
scanf("%d", &x);
stick[i] = x;
for (int j = 0; j + x <= n; j++) dp[j + x] = min(dp[j + x], dp[j] + 1);
}
int ee = 0;
for (int i = 0, p = 0; i < top; p += block[i++]) {
fill(dp, dp + n + 1, inf);
queue<int> qq;
qq.push(p);
dp[p] = 0;
while (qq.size()) {
int v = qq.front();
qq.pop();
int t;
for (int j = 0; j < m; j++) {
if ((t = stick[j] + v) <= n && dp[t] == inf) {
dp[t] = dp[v] + 1;
qq.push(t);
}
if ((t = v - stick[j]) >= 0 && dp[t] == inf) {
dp[t] = dp[v] + 1;
qq.push(t);
}
}
}
int s = p, mask = 0;
for (int j = i; j < top; j++) {
s += block[j];
mask ^= ((1) << (j));
if (dp[s] < inf) {
cc[ee] = dp[s];
mk[ee++] = mask;
}
edge[i][j] = dp[s];
bits[i][j] = mask;
}
}
for (int i = 0; i < ((1) << (top)); i++) dis[i] = inf;
dis[0] = 0;
heap.pushHeap(0);
while (heap.size()) {
int st = heap.popHeap();
if (st == des) break;
int diff = st ^ des;
for (int i = 0; i < top; i++) {
if (0 == (diff & ((1) << (i)))) continue;
for (int j = i; j < top; j++) {
if (edge[i][j] == inf) continue;
int nst = st ^ bits[i][j];
int nd = dis[st] + edge[i][j];
if (nd >= dis[nst]) continue;
if (dis[nst] == inf) {
dis[nst] = nd;
heap.pushHeap(nst);
} else {
dis[nst] = nd;
heap.adjustUp(nst);
}
}
break;
}
}
cout << (dis[des] < inf ? dis[des] : -1) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int s = 0, f = 1;
char ch = getchar();
while (!('0' <= ch && ch <= '9')) {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
s = (s << 3) + (s << 1) + ch - '0';
ch = getchar();
}
return s * f;
}
int n, K, m, sss;
int a[105], b[25];
int g[10005], ans[1 << 20];
int d[22][22];
int main() {
n = read();
K = read();
m = read();
for (int i = 1; i <= K; i++) {
int ss = read();
b[sss++] = ss;
b[sss++] = ss + 1;
}
for (int i = 1; i <= m; i++) a[i] = read();
sort(&b[0], &b[sss]);
for (int j = 0; j < sss; j++) {
queue<int> q;
for (int i = 0; i <= n + 1; i++) g[i] = 100000000;
q.push(b[j]);
g[b[j]] = 0;
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = 1; i <= m; i++) {
if (x + a[i] <= n + 1) {
if (g[x + a[i]] > g[x] + 1) {
g[x + a[i]] = g[x] + 1;
q.push(x + a[i]);
}
}
if (x - a[i] > 0) {
if (g[x - a[i]] > g[x] + 1) {
g[x - a[i]] = g[x] + 1;
q.push(x - a[i]);
}
}
}
}
for (int i = 0; i < sss; i++) d[j][i] = g[b[i]];
}
for (int i = 1; i < (1 << (sss)); i++) {
ans[i] = 100000000;
int j = sss - 1;
while (!((i >> j) & 1)) j--;
for (int k = j - 1; k >= 0; k--)
if ((i >> k) & 1)
ans[i] = min(ans[i], ans[i ^ (1 << j) ^ (1 << k)] + d[j][k]);
}
printf("%d\n",
(ans[(1 << (sss)) - 1] == 100000000 ? -1 : ans[(1 << (sss)) - 1]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, l, dat[10005], len[105], dis[25][25], dp[(1 << 20) + 5];
vector<int> pos;
void bfs(int c, int s) {
int dis[10005];
queue<int> q;
for (int i = 0; i < 10005; ++i) {
dis[i] = 2e9;
}
dis[s] = 0;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < l; ++i) {
int v = u - len[i];
if (v >= 0 && dis[u] + 1 < dis[v]) {
dis[v] = dis[u] + 1;
q.push(v);
}
v = u + len[i];
if (v <= n && dis[u] + 1 < dis[v]) {
dis[v] = dis[u] + 1;
q.push(v);
}
}
}
for (int i = 0; i < m; ++i) {
::dis[c][i] = dis[pos[i]];
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k >> l;
for (int i = 0; i < k; ++i) {
int pos;
cin >> pos;
dat[pos] ^= 1;
dat[--pos] ^= 1;
}
for (int i = 0; i < l; ++i) {
cin >> len[i];
}
for (int i = 0; i < 25; ++i) {
for (int j = 0; j < 25; ++j) {
dis[i][j] = 2e9;
}
}
for (int i = 0; i < n + 1; ++i) {
if (dat[i]) {
pos.push_back(i);
}
}
m = (int)pos.size();
for (int i = 0; i < m; ++i) {
bfs(i, pos[i]);
}
for (int S = 0; S < (1 << m) - 1; ++S) {
dp[S] = 2e9;
}
dp[(1 << m) - 1] = 0;
for (int S = (1 << m) - 1; S >= 0; --S) {
for (int i = 0; i < m; ++i) {
if ((S >> i) & 1) {
for (int j = 0; j < m; ++j) {
if (i != j && (S >> j) & 1) {
int nS = S;
nS ^= (1 << i);
nS ^= (1 << j);
if (dis[i][j])
dp[nS] = min((long long)dp[nS], (long long)dp[S] + dis[i][j]);
}
}
}
}
}
if (dp[0] == 2e9) {
cout << -1 << endl;
} else {
cout << dp[0] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10005;
const int INF = 1000000005;
int dp[1 << 20];
int d[N];
int W[20][20];
int x[20];
int a[105];
int n, K, L;
inline void checkMin(int &a, const int &b) {
if (b < a) a = b;
}
int main() {
cin >> n >> K >> L;
set<int> M;
M.clear();
for (int i = 0; i < K; i++) {
scanf("%d", &x[i]);
}
sort(x, x + K);
K = unique(x, x + K) - x;
for (int i = 0; i < K; i++) {
pair<set<int>::iterator, bool> p = M.insert(x[i] - 1);
if (!p.second) {
M.erase(p.first);
}
p = M.insert(x[i]);
if (!p.second) {
M.erase(p.first);
}
}
K = copy(M.begin(), M.end(), x) - x;
for (int i = 0; i < L; i++) {
scanf("%d", &a[i]);
}
sort(a, a + L);
L = unique(a, a + L) - a;
int Q[N * 2];
int qi[2] = {-1, 1};
for (int i = 0; i < K; i++) {
fill(d, d + n + 1, INF);
d[x[i]] = 0;
int head = 0, tail = 0;
Q[tail++] = x[i];
while (head != tail) {
int nx = Q[head++];
for (int j = 0; j < L; j++) {
for (int k = 0; k < 2; k++) {
int tx = nx + qi[k] * a[j];
if (tx < 0 || tx > n) continue;
if (d[tx] == INF) {
d[tx] = d[nx] + 1;
Q[tail++] = tx;
}
}
}
}
for (int j = 0; j < K; j++) {
W[i][j] = d[x[j]];
}
}
fill(dp, dp + (1 << K), INF);
dp[0] = 0;
int all = (1 << K);
for (int msk = 0; msk < all - 1; msk++) {
if (dp[msk] >= INF) continue;
for (int u = 0; u < K; u++) {
for (int v = 0; v < K; v++) {
if (u != v && !(msk & (1 << u)) && !(msk & (1 << v))) {
if (dp[msk | (1 << u) | (1 << v)] > dp[msk] + W[u][v]) {
dp[msk | (1 << u) | (1 << v)] = dp[msk] + W[u][v];
}
}
}
}
}
if (dp[all - 1] >= INF) {
printf("-1\n");
} else {
printf("%d\n", dp[all - 1]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
const int P = 1048576 + 10;
const int Y = 30;
int tr[N];
int cnt;
int cf[N];
int a[N];
int n;
int m;
int k;
int cst[Y][Y];
int d[N];
int dp[P];
queue<int> q;
inline void bfs(int s) {
for (int i = 1; i <= n + 1; i++) d[i] = 0x3f3f3f3f;
d[s] = 0;
int nw;
int i = 1;
for (q.push(s); !q.empty();)
for (nw = q.front(), q.pop(), i = 1; i <= m; i++) {
int v1 = nw + a[i];
if (v1 <= n + 1 && d[v1] == 0x3f3f3f3f) d[v1] = d[nw] + 1, q.push(v1);
int v2 = nw - a[i];
if (v2 >= 1 && d[v2] == 0x3f3f3f3f) d[v2] = d[nw] + 1, q.push(v2);
}
for (int i = 1; i <= n + 1; i++)
if (tr[i] != -1) cst[tr[s]][tr[i]] = d[i];
}
int main() {
cin >> n >> k >> m;
for (int i = 1, t; i <= k; i++) {
scanf("%d", &t);
cf[t] = 1;
}
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
for (int i = n + 1; i >= 1; i--) cf[i] ^= cf[i - 1];
cnt = -1;
for (int i = 1; i <= n + 1; i++) tr[i] = -1;
for (int i = 1; i <= n + 1; i++)
if (cf[i]) tr[i] = ++cnt;
for (int i = 1; i <= n + 1; i++)
if (cf[i]) bfs(i);
for (int i = 1; i < (1 << (cnt + 1)); i++) dp[i] = 0x3f3f3f3f;
for (int i = 0; i < (1 << (cnt + 1)); i++) {
if (dp[i] == 0x3f3f3f3f) continue;
for (int j = 0; j <= cnt; j++) {
if ((i >> j) & 1) continue;
for (int k = j + 1; k <= cnt; k++)
if (((i >> k) & 1) == 0)
dp[i + (1 << j) + (1 << k)] =
min(dp[i + (1 << j) + (1 << k)], dp[i] + cst[j][k]);
}
}
int ans = dp[(1 << (cnt + 1)) - 1];
printf("%d\n", (ans == 0x3f3f3f3f) ? -1 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool fl[11000], stream[11000];
int n, k, l, tmp, a[11000], dis[22][11000], pos[22];
vector<int> nodes;
void BFS(int s, int cord) {
dis[s][cord] = 0;
queue<int> q;
q.push(cord);
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int i = 1; i <= l; i++) {
int nc1 = cur - a[i];
int nc2 = cur + a[i];
if (nc1 >= 0 && nc1 <= n) {
if (dis[s][nc1] > dis[s][cur] + 1) {
dis[s][nc1] = dis[s][cur] + 1;
if (!stream[nc1]) q.push(nc1);
}
}
if (nc2 >= 0 && nc2 <= n) {
if (dis[s][nc2] > dis[s][cur] + 1) {
dis[s][nc2] = dis[s][cur] + 1;
if (!stream[nc2]) q.push(nc2);
}
}
}
}
}
int dp[(1 << 20) + 10];
int main() {
scanf("%d %d %d", &n, &k, &l);
for (int i = 1; i <= k; i++) scanf("%d", &tmp), fl[tmp] = 1;
for (int i = 1; i <= l; i++) scanf("%d", &a[i]);
for (int i = 0; i <= n; i++) {
stream[i] = (fl[i] != fl[i + 1]);
if (stream[i]) pos[i] = nodes.size(), nodes.push_back(i);
}
memset(dis, 0x3f, sizeof dis);
for (int i = 0; i < nodes.size(); i++) BFS(i, nodes[i]);
int tot = nodes.size();
memset(dp, 0x3f, sizeof dp);
dp[0] = 0;
for (int mask = 1; mask < (1 << tot); mask++) {
int low = -1;
for (int i = 0; i < tot && (low == -1); i++)
if (mask & (1 << i)) low = i;
for (int j = 0; j < tot; j++)
if ((mask & (1 << j)) && j != low)
dp[mask] = min(dp[mask],
dis[low][nodes[j]] + dp[mask ^ (1 << low) ^ (1 << j)]);
}
cout << ((dp[(1 << tot) - 1] == dp[1]) ? -1 : dp[(1 << tot) - 1]) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int dis[10005], cost[101][101], x, n, cnt, k, l, delta[10005], pos[100];
int inf = 0x3f3f3f3f, len[101], dp[(1 << 20) + 1];
void bfs(int s) {
queue<int> q;
memset(dis, 0x3f, sizeof(dis));
q.push(pos[s]);
dis[pos[s]] = 0;
while (!q.empty()) {
int from = q.front();
q.pop();
for (int i = 1; i <= l; i++) {
if (from + len[i] <= n + 1 && dis[from + len[i]] == inf) {
dis[from + len[i]] = dis[from] + 1;
q.push(from + len[i]);
}
if (from - len[i] >= 1 && dis[from - len[i]] == inf) {
dis[from - len[i]] = dis[from] + 1;
q.push(from - len[i]);
}
}
}
for (int i = 1; i <= cnt; i++)
if (dis[pos[i]] != inf) cost[s][i] = dis[pos[i]];
}
int main() {
scanf("%d%d%d", &n, &k, &l);
for (int i = 1; i <= k; i++) {
scanf("%d", &x);
delta[x] ^= 1;
delta[x + 1] ^= 1;
}
for (int i = 1; i <= l; i++) scanf("%d", &len[i]);
for (int i = 1; i <= n + 1; i++)
if (delta[i] == 1) pos[++cnt] = i;
memset(cost, 0x3f, sizeof(cost));
for (int i = 1; i <= cnt; i++) bfs(i);
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for (int i = 1; i <= (1 << cnt) - 1; i++) {
for (int j = 1; j <= cnt; j++) {
if ((1 << (j - 1)) & i) {
for (int k1 = j + 1; k1 <= cnt; k1++) {
if ((1 << (k1 - 1)) & i) {
int from = ((i ^ (1 << (j - 1))) ^ (1 << (k1 - 1)));
dp[i] = min(dp[i], dp[from] + cost[j][k1]);
}
}
}
}
}
if (dp[(1 << cnt) - 1] != inf)
printf("%d\n", dp[(1 << cnt) - 1]);
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 1e4 + 22;
const int inf = 1e9;
int n, k, l, x, a[maxn], G[44][44], f[(1 << 20) + 22], c[44], dis[maxn], tl;
std::vector<int> ch[maxn];
void bfs(int u) {
std::memset(dis, 63, sizeof(dis));
dis[u] = 0;
std::queue<int> q;
q.push(u);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int v : ch[u]) {
if (dis[v] > dis[u] + 1) {
dis[v] = dis[u] + 1;
q.push(v);
}
}
}
}
int main() {
scanf("%d%d%d", &n, &k, &l);
for (int i = 1; i <= k; ++i) {
scanf("%d", &x);
f[x] ^= 1;
f[x + 1] ^= 1;
}
for (int i = 1; i <= l; ++i) scanf("%d", &a[i]);
n++;
for (int i = 1; i <= n; ++i) {
if (f[i]) c[++tl] = i;
for (int j = 1; j <= l; ++j) {
if (i + a[j] <= n) ch[i].push_back(i + a[j]);
if (i - a[j] >= 1) ch[i].push_back(i - a[j]);
}
}
for (int i = 1; i <= tl; ++i) {
bfs(c[i]);
for (int j = 1; j <= tl; ++j) G[i][j] = dis[c[j]];
}
std::memset(f, 63, sizeof(f));
f[0] = 0;
for (int S = 0; S < (1 << tl); ++S) {
for (int i = 1; i <= tl; ++i)
for (int j = i + 1; j <= tl; ++j) {
int p = (1 << (i - 1)), q = (1 << (j - 1));
if ((S & p) && (S & q)) f[S] = std::min(f[S], f[S - p - q] + G[i][j]);
}
}
auto ans = f[(1 << tl) - 1];
if (ans >= inf)
puts("-1");
else
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000 * 1000 * 1000 + 7;
const int maxn = 10000 + 10;
const int inf = 100000000;
const int base = 139;
int n, k, l, b[maxn], first[11], c[maxn], r, t, d[maxn], dist[22][22],
dp[(1 << 20) + 3];
vector<int> v[maxn], a;
bool mark[maxn];
void bfs(int e) {
queue<int> q;
memset(mark, 0, sizeof mark);
for (int i = 0; i < maxn; i++) d[i] = inf;
q.push(e);
d[e] = 0;
mark[e] = 1;
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = 0; i < v[x].size(); i++)
if (!mark[v[x][i]]) {
q.push(v[x][i]);
d[v[x][i]] = d[x] + 1;
mark[v[x][i]] = 1;
}
}
for (int i = 0; i <= n; i++)
if (b[i]) dist[b[e]][b[i]] = d[i];
}
int f(int x) {
if (!x) return 0;
if (dp[x] != -1) return dp[x];
int o = -1, res = inf;
for (int i = 0; i < r; i++) {
if ((1 << i) & x) {
if (o == -1)
o = i;
else
res = min(res, f(x - (1 << o) - (1 << i)) + dist[o + 1][i + 1]);
}
}
return dp[x] = res;
}
int main() {
memset(dp, -1, sizeof dp);
for (int i = 0; i < 22; i++)
for (int j = 0; j < 22; j++) dist[i][j] = inf;
cin >> n >> k >> l;
for (int i = 1; i <= k; i++) {
cin >> first[i];
c[first[i]] = 1;
}
for (int i = 1; i <= l; i++) {
int x;
cin >> x;
a.push_back(x);
}
sort(a.begin(), a.end());
a.resize(unique(a.begin(), a.end()) - a.begin());
for (int i = 0; i <= n; i++)
if (c[i] != c[i + 1]) b[i] = ++t;
for (int i = 0; i < l; i++)
for (int j = 0; j + a[i] <= n; j++) {
v[j].push_back(j + a[i]);
v[j + a[i]].push_back(j);
}
for (int i = 0; i <= n; i++)
if (b[i]) {
r++;
bfs(i);
}
int k = f((1 << r) - 1);
if (k >= inf)
cout << -1 << endl;
else
cout << k << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int maxn = 10005;
int n, k, l;
vector<int> step;
bool arr[maxn];
int dis[22][maxn];
int m = 0;
const int inf = 1 << 28;
vector<int> pos;
int dp[1 << 22];
int get(int msk) {
for (int i = 0; i < m; ++i) {
if ((msk) & (1 << i)) return i;
}
assert(false);
return 0;
}
int match[22][22];
int solve(int msk) {
if (msk == 0) return 0;
int &ret = dp[msk];
if (ret != -1) return ret;
ret = inf;
int curr = get(msk);
for (int i = 0; i < m; ++i) {
if (curr == i) continue;
if ((msk & (1 << i)) && match[i][curr] != inf) {
int nmsk = msk & ~(1 << i);
nmsk &= ~(1 << curr);
ret = min(ret, match[i][curr] + solve(nmsk));
}
}
return ret;
}
void bfs(int ind) {
queue<int> q;
dis[ind][pos[ind]] = 0;
q.push(pos[ind]);
while (!q.empty()) {
int v = q.front();
q.pop();
for (int j = 0; j < ((int)((step).size())); j++) {
int c = step[j] + v;
if (c <= n && dis[ind][c] > dis[ind][v] + 1) {
dis[ind][c] = dis[ind][v] + 1;
q.push(c);
}
c = v - step[j];
if (c >= 0 && dis[ind][c] > dis[ind][v] + 1) {
dis[ind][c] = dis[ind][v] + 1;
q.push(c);
}
}
}
}
int main() {
scanf("%d %d %d", &n, &k, &l);
memset(dp, -1, sizeof(dp));
for (int i = 0; i < k; ++i) {
int x;
scanf("%d", &x);
arr[x] = 1;
}
step.resize(l);
for (int i = 0; i < l; ++i) {
scanf("%d", &step[i]);
}
for (int i = 0; i <= n; ++i) {
if (arr[i] ^ arr[i + 1]) {
++m;
pos.push_back(i);
}
}
for (int i = 0; i < m; ++i) {
for (int j = 0; j < maxn; ++j) dis[i][j] = inf;
bfs(i);
}
for (int i = 0; i < m; ++i) {
match[i][i] = 0;
for (int j = i + 1; j < m; ++j) {
match[i][j] = match[j][i] = inf;
for (int k = 0; k <= n; ++k) {
match[i][j] = min(match[i][j], dis[i][k] + dis[j][k]);
}
match[j][i] = match[i][j];
}
}
int ans = solve((1 << m) - 1);
if (ans == inf) ans = -1;
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, K, O, x;
int a[10010], b[10010], id[10010], g[10010], gg[10010], f[1 << 20], c[20][20];
int main() {
scanf("%d%d%d", &n, &K, &m);
n++;
for (i = 1; i <= K; i++) {
scanf("%d", &x);
a[x] ^= 1, a[x + 1] ^= 1;
}
for (i = 1; i <= m; i++) scanf("%d", &b[i]);
for (i = 1; i <= n; i++)
if (a[i]) id[i] = ++O;
for (i = 1; i <= n; i++)
if (a[i]) {
int l, r;
for (j = 1; j <= n; j++) gg[j] = -1;
g[l = r = 1] = i;
gg[i] = 0;
for (; l <= r; l++) {
int A = g[l];
for (j = 1; j <= m; j++)
for (k = -1; k <= 1; k++) {
int B = A + k * b[j];
if (B > 0 && B <= n && gg[B] < 0) {
gg[B] = gg[A] + 1;
g[++r] = B;
}
}
}
for (j = 1; j <= n; j++)
if (a[j] && gg[j] >= 0 && j != i) {
int A = id[i], B = id[j];
if (A > B) swap(A, B);
c[A - 1][B - 1] = gg[j];
}
}
memset(f, 120, sizeof(f));
f[0] = 0;
int nn = (1 << O) - 1;
for (i = 0; i <= nn; i++)
if (f[i] < 1e9) {
for (j = 0; j <= O - 1; j++)
if (!(i >> j & 1)) {
for (k = j + 1; k <= O - 1; k++)
if (!(i >> k & 1) && c[j][k]) {
int A = i | 1 << j | 1 << k;
f[A] = min(f[A], f[i] + c[j][k]);
}
}
}
printf("%d\n", f[nn] > 1e9 ? -1 : f[nn]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10010;
const int inf = 0x3fffffff;
int dp[1 << 20], w[20][20], d[maxn], x[20], a[100];
inline int rightZeroBit(int mask) {
for (int i = 0;; i++) {
if ((mask & (1 << i)) == 0) return i;
}
return -1;
}
int main() {
int n, k, l;
while (scanf("%d%d%d", &n, &k, &l) == 3) {
for (int i = 0; i < k; i++) scanf("%d", &x[i]);
for (int i = 0; i < l; i++) scanf("%d", &a[i]);
sort(a, a + l);
l = unique(a, a + l) - a;
set<int> iset;
for (int i = 0; i < k; i++) {
pair<set<int>::iterator, bool> p;
p = iset.insert(x[i] - 1);
if (!p.second) iset.erase(p.first);
p = iset.insert(x[i]);
if (!p.second) iset.erase(p.first);
}
k = copy(iset.begin(), iset.end(), x) - x;
for (int i = 0; i < k; i++) {
fill(d, d + n + 1, inf);
d[x[i]] = 0;
priority_queue<pair<int, int> > pq;
pq.push(make_pair(0, x[i]));
while (!pq.empty()) {
int s = pq.top().second;
int t = -pq.top().first;
pq.pop();
if (d[s] != t) continue;
for (int j = 0; j < l; j++) {
if (s - a[j] >= 0 && d[s - a[j]] > t + 1) {
d[s - a[j]] = t + 1;
pq.push(make_pair(-d[s - a[j]], s - a[j]));
}
if (s + a[j] <= n && d[s + a[j]] > t + 1) {
d[s + a[j]] = t + 1;
pq.push(make_pair(-d[s + a[j]], s + a[j]));
}
}
}
for (int j = 0; j < k; j++) w[i][j] = d[x[j]];
}
fill(dp, dp + (1 << k), inf);
dp[0] = 0;
for (int mask = 0; mask < (1 << k); mask++) {
int u;
for (u = 0; u < k; u++)
if ((mask & (1 << u)) == 0) break;
if (u >= k) continue;
for (int v = 0; v < k; v++)
if ((mask & (1 << v)) == 0) {
int _mask = mask ^ (1 << u) ^ (1 << v);
dp[_mask] = min(dp[_mask], dp[mask] + w[u][v]);
}
}
printf("%d\n", dp[(1 << k) - 1] == inf ? -1 : dp[(1 << k) - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10 * 1000 + 10, maxm = (1 << 17), mod = (int)1e9 + 7,
hash = 701, inf = (1 << 29) + 3;
const double pi = 3.14159265359, ee = 2.71828;
int dis[30][30], d[(1 << 21)], dd[maxn], l[110], n, m, k, u;
vector<int> q, bf;
void bfs(int v) {
dd[v] = 0, bf.push_back(v);
for (int i = 0; i < bf.size(); i++) {
v = bf[i];
for (int j = 0; j < m; j++) {
if (v + l[j] <= n)
if (dd[v + l[j]] > dd[v] + 1)
dd[l[j] + v] = dd[v] + 1, bf.push_back(v + l[j]);
if (v - l[j] >= 0)
if (dd[v - l[j]] > dd[v] + 1)
dd[v - l[j]] = dd[v] + 1, bf.push_back(v - l[j]);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> k >> m;
for (int i = 0; i < k; i++) cin >> u, q.push_back(u), q.push_back(u - 1);
for (int i = 0; i < m; i++) cin >> l[i];
for (int i = 0; i < q.size(); i++) {
for (int j = 0; j <= n; j++) dd[j] = inf;
bfs(q[i]);
for (int j = 0; j < q.size(); j++) dis[i][j] = dd[q[j]];
}
for (int i = 1; i < (1 << q.size()); i++) d[i] = inf, u = 0;
for (int i = 1; i < (1 << q.size()); i++, u = 0) {
while (!(i & (1 << u))) u++;
for (int j = 0; j < q.size(); j++)
if (j != u && (i & (1 << j)))
d[i] = min(d[i], d[i ^ (1 << u) ^ (1 << j)] + dis[u][j]);
}
cout << (d[(1 << q.size()) - 1] == inf ? -1 : d[(1 << q.size()) - 1]) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1 << 28;
const long long LINF = 1ll << 61;
inline long long getnum() {
register long long r = 0;
register bool ng = 0;
register char c;
c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
if (c == '-') ng = 1, c = getchar();
while (c != ' ' && c != '\n') r = r * 10 + c - '0', c = getchar();
if (ng) r = -r;
return r;
}
template <class T>
inline void putnum(T x) {
if (x < 0) putchar('-'), x = -x;
register short a[20] = {}, sz = 0;
while (x > 0) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
inline void putsp() { putchar(' '); }
inline void putendl() { putchar('\n'); }
inline char mygetchar() {
register char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
return c;
}
int n, m, l;
bool f[10011];
int pos[22], sz;
int dis[10011];
int D[22][22];
set<pair<int, int> > st;
vector<int> to;
void bfs(int x) {
memset(dis, -1, sizeof(dis));
queue<int> q;
q.push(x);
dis[x] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < to.size(); i++) {
int nxt;
nxt = u + to[i];
if (nxt >= 1 && nxt <= n && dis[nxt] == -1) {
dis[nxt] = dis[u] + 1;
q.push(nxt);
}
nxt = u - to[i];
if (nxt >= 1 && nxt <= n && dis[nxt] == -1) {
dis[nxt] = dis[u] + 1;
q.push(nxt);
}
}
}
}
int dp[1048576];
int main() {
n = getnum(), m = getnum(), l = getnum();
n++;
for (int i = 1; i <= m; i++) {
int x;
x = getnum();
f[x] ^= 1;
f[x + 1] ^= 1;
}
memset(dis, -1, sizeof(dis));
for (int i = 1; i <= l; i++) {
int x;
x = getnum();
to.push_back(x);
}
for (int i = 1; i <= n; i++) {
if (f[i]) {
pos[sz++] = i;
}
}
for (int i = 0; i < sz; i++) {
bfs(pos[i]);
for (int j = 0; j < sz; j++) {
D[i][j] = dis[pos[j]];
}
}
memset(dp, 127, sizeof(dp));
int tinf = dp[0];
dp[(1 << sz) - 1] = 0;
for (int i = (1 << sz) - 1; i >= 0; i--) {
for (int j = 0; j < sz; j++) {
if (!((i >> j) & 1)) continue;
for (int k = j + 1; k < sz; k++) {
if (!((i >> k) & 1)) continue;
if (D[j][k] != -1) {
int &nxt = dp[i & (~(1 << j)) & (~(1 << k))];
nxt = min(nxt, dp[i] + D[j][k]);
}
}
}
}
if (dp[0] == tinf)
puts("-1");
else
cout << dp[0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxN = 1e4, mxK = 10, mxL = 100;
int n, k, l, xi, m, x[2 * mxK], a[2 * mxL], qu[mxN + 1], d[mxN + 1],
c[2 * mxK][2 * mxK], dp[1 << (2 * mxK)];
bool b[mxN + 1];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> l;
for (int i = 0; i < k; ++i) {
cin >> xi;
b[xi] ^= 1;
b[xi - 1] ^= 1;
}
for (int i = 0; i <= n; ++i)
if (b[i]) x[m++] = i;
for (int i = 0; i < l; ++i) {
cin >> a[i];
a[i + l] = -a[i];
}
for (int i = 0; i < m; ++i) {
int qt = 0;
qu[qt++] = x[i];
memset(d, 1, 4 * (n + 1));
d[x[i]] = 0;
for (int qh = 0; qh < qt; ++qh) {
int u = qu[qh];
for (int j = 0; j < 2 * l; ++j) {
if (u + a[j] >= 0 && u + a[j] <= n && d[u + a[j]] > 1e7) {
qu[qt++] = u + a[j];
d[u + a[j]] = d[u] + 1;
}
}
}
for (int j = i + 1; j < m; ++j) c[i][j] = d[x[j]];
}
memset(dp, 1, 4 << m);
dp[0] = 0;
for (int i = 3; i < 1 << m; ++i) {
if (__builtin_popcount(i) & 1) continue;
for (int j = 0; j < m; ++j)
if (i >> j & 1)
for (int k = j + 1; k < m; ++k)
if (i >> k & 1) dp[i] = min(dp[i ^ 1 << j ^ 1 << k] + c[j][k], dp[i]);
}
cout << (dp[(1 << m) - 1] > 1e7 ? -1 : dp[(1 << m) - 1]);
}
|
#include <bits/stdc++.h>
using namespace std;
void bfs(int s, bitset<10000 + 5>& panel, int dis[], int a[], int L, int N,
int id[], int size) {
fill(dis, dis + size, 1 << 24);
dis[id[s]] = 0;
int cal_dis[10000 + 5];
fill(cal_dis, cal_dis + 10000 + 5, -1);
cal_dis[s] = 0;
queue<int> que;
que.push(s);
while (!que.empty()) {
int cur = que.front();
que.pop();
for (int i = 0; i < L; ++i) {
int v = cur + a[i];
if (v >= N || v == s || cal_dis[v] != -1) continue;
cal_dis[v] = cal_dis[cur] + 1;
if (panel[v] == 1) {
dis[id[v]] = cal_dis[v];
} else {
que.push(v);
}
}
for (int i = 0; i < L; ++i) {
int v = cur - a[i];
if (v < 0 || v == s || cal_dis[v] != -1) continue;
cal_dis[v] = cal_dis[cur] + 1;
if (panel[v] == 1) {
dis[id[v]] = cal_dis[v];
} else {
que.push(v);
}
}
}
}
int dp[1 << 24];
int main() {
int N, K, L;
bitset<10000 + 5> panel;
int x[10 + 5], a[100 + 5];
cin >> N >> K >> L;
for (int i = 0; i < K; ++i) {
cin >> x[i];
panel[x[i]] = 1;
}
for (int i = 0; i < L; ++i) {
cin >> a[i];
}
panel = panel ^ (panel >> 1);
vector<int> vertices;
int dis[24][24];
int id[10000 + 5];
int size = 0;
for (int i = 0; i < N + 1; ++i) {
if (panel[i] == 1) {
id[i] = size++;
}
}
for (int i = 0; i < N + 1; ++i) {
if (panel[i] == 1) {
bfs(i, panel, dis[id[i]], a, L, N + 1, id, size);
}
}
int mask = 1 << size;
fill(dp, dp + mask, 1 << 24);
dp[0] = 0;
for (int i = 3; i < mask; ++i) {
for (int k = 0; k < size; ++k) {
if (i & (1 << k)) {
for (int j = k + 1; j < size; ++j) {
if (i & (1 << j)) {
int p = i - (1 << k) - (1 << j);
int d = min(dis[k][j], dis[j][k]);
if (dp[p] < (1 << 24) && d < (1 << 24)) {
dp[i] = min(dp[i], dp[p] + d);
}
}
}
}
}
}
if (dp[mask - 1] < 1 << 24)
cout << dp[mask - 1] << endl;
else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10010;
int n, k, l, x[30], y[30], d[30][30], a[110], dp[1 << 20];
map<int, int> M;
vector<int> G[N];
inline void AE(int u, int v) {
G[u].push_back(v);
G[v].push_back(u);
}
int dis[N];
queue<int> Q;
inline void bfs(int st) {
for (int i = 1; i <= n; i++) dis[i] = 1e9;
dis[st] = 0;
Q.push(st);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int v : G[u])
if (dis[v] == 1e9) {
dis[v] = dis[u] + 1;
Q.push(v);
}
}
}
int main() {
scanf("%d%d%d", &n, &k, &l);
++n;
for (int i = 1; i <= k; i++) scanf("%d", x + i);
for (int i = 1; i <= l; i++) scanf("%d", a + i);
for (int i = 1; i <= k; i++) ++M[x[i]], ++M[x[i] + 1];
k = 0;
for (pair<int, int> p : M)
if (p.second & 1) {
y[k++] = p.first;
}
if (k & 1) return puts("-1"), 0;
for (int i = 1; i <= l; i++)
for (int j = 0; j <= n - a[i]; j++) AE(j, j + a[i]);
for (int i = 0; i <= k - 1; i++) {
bfs(y[i]);
for (int j = 0; j <= k - 1; j++) d[i][j] = dis[y[j]];
}
dp[0] = 0;
for (int S = 1; S <= (1 << k) - 1; S++)
if (!(__builtin_popcount(S) & 1)) {
dp[S] = 1e9;
for (int i = 0; i <= k - 1; i++)
if (S >> i & 1)
for (int j = i + 1; j <= k - 1; j++)
if (S >> j & 1) {
dp[S] = min(dp[S], dp[S ^ (1 << i) ^ (1 << j)] + d[i][j]);
}
}
if (dp[(1 << k) - 1] == 1e9) return puts("-1"), 0;
printf("%d\n", dp[(1 << k) - 1]);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int sum = 0, t = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') t = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
sum = sum * 10 + ch - '0';
ch = getchar();
}
return sum * t;
}
int n, k, l;
int x[2050], a[2050];
int p[2050 << 1], lg2[2050 * 2050];
int edge[30][30], f[2050 * 2050];
int dis[2050 * 10];
void bfs(int S) {
queue<int> q;
memset(dis, -1, sizeof(dis));
q.push(S);
dis[S] = 0;
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = 1; i <= l; i++) {
int t = x + a[i];
if (t <= n && dis[t] == -1) dis[t] = dis[x] + 1, q.push(t);
t = x - a[i];
if (t >= 0 && dis[t] == -1) dis[t] = dis[x] + 1, q.push(t);
}
}
}
int main() {
n = read(), k = read(), l = read();
for (int i = 1; i <= k; i++) x[i] = read();
for (int i = 1; i <= l; i++) a[i] = read();
sort(a + 1, a + l + 1);
l = unique(a + 1, a + l + 1) - a - 1;
int K_ = 0;
x[0] = x[1], x[k + 1] = x[k];
for (int i = 1; i <= k; i++) {
if (x[i] != x[i - 1] + 1) p[K_++] = x[i] - 1;
if (x[i] != x[i + 1] - 1) p[K_++] = x[i];
}
k = K_;
for (int i = 0; i < k; i++) lg2[1 << i] = i;
for (int i = 0; i < k; i++) {
bfs(p[i]);
for (int j = 0; j < k; j++)
if (dis[p[j]] != -1)
edge[i][j] = dis[p[j]];
else
edge[i][j] = 0x3f3f3f3f;
}
memset(f, -1, sizeof(f));
f[0] = 0;
for (int S = 1; S < 1 << k; S++) {
int s0 = S & -S;
f[S] = 0x3f3f3f3f;
int S_ = S ^ s0;
for (int i = 0; i < k; i++)
if (S_ >> i & 1)
f[S] = min(f[S], f[S ^ s0 ^ (1 << i)] + edge[lg2[s0]][i]);
}
if (f[(1 << k) - 1] != 0x3f3f3f3f)
printf("%d\n", f[(1 << k) - 1]);
else
puts("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 60;
int in() {
char c;
bool g = false;
while (c = getchar(), c < '0' || c > '9')
if (c == '-')
g = true;
else
g = false;
int x = 0;
while (c >= '0' && c <= '9') {
x = x * 10 + c - 48;
c = getchar();
}
return g ? -x : x;
}
void out(int x) {
int len = 0, data[30];
while (x) {
data[len++] = x % 10;
x /= 10;
}
if (!len) data[len++] = 0;
if (data[0] != abs(data[0])) putchar('-');
while (len--) putchar(abs(data[len]) + 48);
putchar('\n');
}
const long long N = 100100;
long long a[N], b[N], q[N], n, k, l, dp[(1 << 21)], d[30][N], bg, ed;
bool vis[N], ans[N];
int main() {
n = in() + 1, k = in(), l = in();
while (k--) ans[in()]++;
k++;
for (int i = 0; i < l; i++) a[i] = in();
for (int i = 0; i < n; i++) ans[i] = ans[i] ^ ans[i + 1];
for (int i = 0; i < n; i++)
if (ans[i]) b[k++] = i;
for (int t = 0; t < k; t++) {
for (int i = 0; i < n; i++) d[t][i] = INF, vis[i] = false;
d[t][b[t]]++;
bg = ed = 0;
q[ed++] = b[t];
d[t][b[t]] = 0;
while (ed > bg) {
int u = q[bg++];
for (int i = 0; i < l; i++) {
if (u < n - a[i] && !vis[u + a[i]]++)
q[ed++] = u + a[i],
((d[t][u + a[i]]) = min((d[t][u + a[i]]), (d[t][u] + 1)));
if (u >= a[i] && !vis[u - a[i]]++)
q[ed++] = u - a[i],
((d[t][u - a[i]]) = min((d[t][u - a[i]]), (d[t][u] + 1)));
}
}
}
for (int mask = 0; mask < (1 << k); mask++)
if (!mask)
dp[mask] = 0;
else {
dp[mask] = INF;
for (int i = 0; i < k; i++)
for (int j = i + 1; j < k; j++)
if ((mask >> i) & (mask >> j) & 1)
((dp[mask]) = min((dp[mask]),
(dp[mask ^ (1 << i) ^ (1 << j)] + d[i][b[j]])));
}
if (dp[(1 << k) - 1] >= INF)
cout << -1 << endl;
else
cout << dp[(1 << k) - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10, INF = 1e8;
int n, m, k, a[N], size[110], num, tot, b[21], dis[21][N], check[N], S,
dp[1 << 20];
struct node {
int x, w;
bool operator<(node p) const { return p.w < w; }
};
priority_queue<node> q;
inline int read() {
int x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x;
}
inline void Dijkstra(int st) {
for (register int i = 1; i <= n + 1; ++i) dis[st][i] = INF, check[i] = 0;
dis[st][b[st]] = 0;
node t = (node){b[st], 0};
q.push(t);
while (!q.empty()) {
node t = q.top();
q.pop();
int u = t.x;
if (check[u]) continue;
check[u] = 1;
for (register int i = 1; i <= num; ++i) {
int v = u + size[i];
if (v <= n + 1 && dis[st][u] + 1 < dis[st][v]) {
dis[st][v] = dis[st][u] + 1;
node t = (node){v, dis[st][v]};
q.push(t);
}
v = u - size[i];
if (v >= 1 && dis[st][u] + 1 < dis[st][v]) {
dis[st][v] = dis[st][u] + 1;
node t = (node){v, dis[st][v]};
q.push(t);
}
}
}
}
int search(int s) {
if (dp[s] != -1) return dp[s];
if (s == S) return dp[s] = 0;
int t = 1;
while ((s >> (t - 1)) & 1) t++;
int minv = INF;
for (register int i = t + 1; i <= tot; ++i)
if (!((s >> (i - 1)) & 1))
minv =
min(minv, search(s | (1 << (t - 1)) | (1 << (i - 1))) + dis[t][b[i]]);
return dp[s] = minv;
}
int main() {
n = read();
k = read();
m = read();
memset(a, 0, sizeof(a));
for (register int i = 1; i <= k; ++i) {
int x = read();
a[x] = 1;
}
for (register int i = 1; i <= m; ++i) size[i] = read();
num = unique(size + 1, size + m + 1) - size - 1;
tot = 0;
for (register int i = 1; i <= n + 1; ++i) {
int x = a[i] ^ a[i - 1];
if (x) b[++tot] = i;
}
for (register int i = 1; i <= tot; ++i) Dijkstra(i);
S = (1 << tot) - 1;
for (register int i = 0; i <= S; ++i) dp[i] = -1;
int ans = search(0);
if (ans >= INF)
printf("%d\n", -1);
else
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
int n, k, l, a[200], d[20000], dist[20][20], dp[10 + (1 << 20)];
bool f[20000], b[20000];
vector<int> all[20000], bs;
queue<int> q;
void bfs(int x) {
q.push(x);
d[x] = 0;
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = 0; i < all[v].size(); i++)
if (d[all[v][i]] == inf) d[all[v][i]] = d[v] + 1, q.push(all[v][i]);
}
}
int main() {
scanf("%d%d%d", &n, &k, &l);
for (int i = 0; i < k; i++) {
int x;
scanf("%d", &x);
f[x] = true;
}
for (int i = 0; i <= n; i++) {
b[i] = (f[i] ^ f[i + 1]);
if (b[i]) bs.push_back(i);
}
for (int i = 0; i < l; i++) {
scanf("%d", &a[i]);
for (int j = 0; j <= n - a[i]; j++)
all[j].push_back(j + a[i]), all[j + a[i]].push_back(j);
}
for (int i = 0; i < bs.size(); i++) {
fill(d, d + n + 1, inf);
bfs(bs[i]);
for (int j = 0; j < bs.size(); j++) {
dist[i][j] = d[bs[j]];
}
}
int m = bs.size();
fill(dp, dp + (1 << m), inf);
dp[0] = 0;
for (int i = 1; i < (1 << m); i++) {
int fir = -1;
for (int j = 0; j < m; j++) {
if ((i >> j) & 1) {
if (fir == -1)
fir = j;
else
dp[i] = min(dp[i], dp[i ^ ((1 << fir) | (1 << j))] + dist[fir][j]);
}
}
}
if (dp[(1 << m) - 1] >= inf) dp[(1 << m) - 1] = -1;
printf("%d\n", dp[(1 << m) - 1]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10005, M = 21;
int read() {
int f = 1, g = 0;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) g = g * 10 + ch - '0';
return f * g;
}
int n, m, cnt, k, a[N], b[M], f[1 << 20], c[1 << 20];
int que[N], dist[N], dis[M][M];
bool h[N];
int main() {
n = read();
k = read();
m = read();
for (int i = 1; i <= k; i++) {
int x = read();
h[x] ^= 1;
h[x - 1] ^= 1;
}
for (int i = 1; i <= m; i++) a[i] = read();
sort(a + 1, a + m + 1);
m = unique(a + 1, a + m + 1) - a - 1;
for (int i = 0; i <= n; i++)
if (h[i]) b[cnt++] = i;
for (int i = 0; i < cnt; i++) {
memset(h, 0, sizeof(h));
int l = 1, r = 1;
que[l] = b[i];
dist[b[i]] = 0;
while (l <= r) {
int x = que[l++];
for (int j = 1; j <= m; j++) {
if ((x - a[j] >= 0) && (!h[x - a[j]])) {
h[x - a[j]] = 1;
que[++r] = x - a[j];
dist[x - a[j]] = dist[x] + 1;
}
if ((x + a[j] <= n) && (!h[x + a[j]])) {
h[x + a[j]] = 1;
que[++r] = x + a[j];
dist[x + a[j]] = dist[x] + 1;
}
}
}
for (int j = 0; j < cnt; j++)
dis[i][j] = (h[b[j]]) ? dist[b[j]] : 0x3f3f3f3f;
}
f[0] = 0;
for (int i = 1; i < (1 << cnt); i++) {
c[i] = c[i >> 1] + (i & 1);
if (c[i] & 1) continue;
f[i] = 0x3f3f3f3f;
for (int j = 0; j < cnt; j++)
if (i & (1 << j))
for (int k = j + 1; k < cnt; k++)
if (i & (1 << k))
f[i] = min(f[i], f[i ^ (1 << j) ^ (1 << k)] + dis[j][k]);
}
printf("%d\n", (f[(1 << cnt) - 1] < 1000000) ? f[(1 << cnt) - 1] : -1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
const int K = 20;
const int L = 110;
const int inf = 1e9;
int n, k, l;
int val[N], a[N], b[N];
int node[N];
int dis[K + 5][K + 5];
int d[N];
void get_dis(int idx) {
int s = node[idx], nw, nxt;
memset(d, -1, sizeof d);
queue<int> q;
d[s] = 0;
q.push(s);
while (!q.empty()) {
nw = q.front();
q.pop();
for (int i = 1; i <= l; i++) {
nxt = nw + a[i];
if (nxt >= 1 && nxt <= n && d[nxt] == -1) {
d[nxt] = d[nw] + 1;
q.push(nxt);
}
nxt = nw - a[i];
if (nxt >= 1 && nxt <= n && d[nxt] == -1) {
d[nxt] = d[nw] + 1;
q.push(nxt);
}
}
}
for (int i = 1; i <= k; i++) {
dis[idx][i] = d[node[i]];
}
return;
}
int dp[(1 << K) + 10];
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> l;
for (int i = 1, x; i <= k; i++) cin >> x, val[x] = 1;
for (int i = 1; i <= l; i++) cin >> a[i];
for (int i = 1; i <= n + 1; i++) b[i] = val[i] ^ val[i - 1];
++n, k = 0;
for (int i = 1; i <= n; i++) {
if (b[i] == 1) {
node[++k] = i;
}
}
for (int i = 1; i <= k; i++) get_dis(i);
int lim = 1 << k;
memset(dp, 63, sizeof dp);
dp[0] = 0;
for (int S = 1, first; S < lim; S++) {
first = -1;
for (int i = 1; i <= k; i++) {
if (1 << i - 1 & S) {
first = i;
break;
}
}
if (first == -1) continue;
for (int i = 1; i <= k; i++) {
if (i == first) continue;
if (dis[first][i] == -1) continue;
if (1 << i - 1 & S) {
dp[S] =
min(dp[S], dp[S ^ (1 << first - 1) ^ (1 << i - 1)] + dis[first][i]);
}
}
}
if (dp[lim - 1] >= inf) {
cout << -1 << '\n';
exit(0);
}
cout << dp[lim - 1] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int maxn = 1e4 + 5;
const int maxl = 105;
const int maxk = 22;
int n, m, l;
int a[maxn], b[maxl], c[maxn], dis[maxn], f[maxn], dp[1 << maxk];
queue<int> q;
vector<int> vec;
vector<pair<int, int> > g[maxk];
int main() {
scanf("%d%d%d", &n, &m, &l);
for (int i = (0); i < (m); ++i) {
int x;
scanf("%d", &x);
a[x] = 1;
}
for (int i = (1); i <= (n + 1); ++i) c[i] = (a[i] != a[i - 1]);
memset(dis, -1, sizeof(dis));
for (int i = (0); i < (l); ++i) {
scanf("%d", &b[i]);
}
for (int i = (1); i <= (n + 1); ++i)
if (c[i]) vec.push_back(i);
for (int i = (0); i < (vec.size()); ++i) {
memset(dis, -1, sizeof(dis));
dis[vec[i]] = 0;
q.push(vec[i]);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = (0); i < (l); ++i) {
int v;
v = u + b[i];
if (v > 0 && v <= n + 1 && !(~dis[v])) dis[v] = dis[u] + 1, q.push(v);
v = u - b[i];
if (v > 0 && v <= n + 1 && !(~dis[v])) dis[v] = dis[u] + 1, q.push(v);
}
}
for (int j = (i + 1); j < (vec.size()); ++j) {
if (~dis[vec[j]]) g[i].push_back(make_pair(j, dis[vec[j]]));
}
}
for (int msk = (1); msk < (1 << vec.size()); ++msk) dp[msk] = INF;
dp[0] = 0;
for (int msk = (0); msk < (1 << vec.size()); ++msk) {
for (int i = (0); i < (vec.size()); ++i) {
if (!(msk & (1 << i))) {
for (int j = (0); j < (g[i].size()); ++j) {
if (!(msk & (1 << g[i][j].first))) {
dp[msk ^ (1 << i) ^ (1 << g[i][j].first)] =
min(dp[msk ^ (1 << i) ^ (1 << g[i][j].first)],
dp[msk] + g[i][j].second);
}
}
break;
}
}
}
printf("%d\n", (dp[(1 << vec.size()) - 1] == INF)
? (-1)
: (dp[(1 << vec.size()) - 1]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, l;
int num = 1;
int a[10010], x[25];
struct node {
int to;
int next;
} road[3000000];
int head[10010];
int d[10010], q[10010], L = 1, R = 0;
int cost[25][25];
int f[(1 << 20) + 5];
void build(int from, int to) {
road[++num].next = head[from];
road[num].to = to;
head[from] = num;
}
void bfs(int num) {
int s = x[num];
memset(d, 0x3f, sizeof(d));
L = 1, R = 0;
d[s] = 0;
q[++R] = s;
while (L <= R) {
int x = q[L];
L++;
for (int i = head[x]; i; i = road[i].next) {
int y = road[i].to;
if (d[y] > 1e9) {
d[y] = d[x] + 1;
q[++R] = y;
}
}
}
for (int i = 1; i <= k; i++) {
cost[num][i] = d[x[i]];
}
}
int main() {
scanf("%d%d%d", &n, &k, &l);
for (int i = 1; i <= k; i++) {
int X;
scanf("%d", &X);
a[X] = 1;
}
n++;
k = 0;
for (int i = 1; i <= n; i++) {
if (a[i] ^ a[i - 1]) x[++k] = i;
}
if (k & 1) {
printf("-1\n");
return 0;
}
memset(a, 0, sizeof(a));
for (int i = 1; i <= l; i++) {
scanf("%d", &a[i]);
for (int j = 1; j <= n; j++) {
if (j + a[i] <= n) build(j, j + a[i]);
if (j - a[i] >= 1) build(j, j - a[i]);
}
}
for (int i = 1; i <= k; i++) {
bfs(i);
}
memset(f, 0x3f, sizeof(f));
f[0] = 0;
int tot = (1 << k) - 1;
for (int i = 1; i <= tot; i++) {
int cnt = 0;
for (int j = 1; j <= k; j++) {
if ((i >> (j - 1)) & 1) cnt++;
}
if (cnt & 1) continue;
for (int j = 1; j <= k; j++) {
if (((i >> (j - 1)) & 1) == 0) continue;
for (int t = 1; t < j; t++) {
if (((i >> (t - 1)) & 1) == 0) continue;
if (j == t) continue;
f[i] = min(f[i], f[i ^ (1 << (j - 1)) ^ (1 << (t - 1))] + cost[j][t]);
}
}
}
printf("%d\n", f[tot] > 1e9 ? -1 : f[tot]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void bfs(int s, bitset<10000 + 5>& panel, int dis[], int a[], int L, int N,
int id[], int size) {
fill(dis, dis + size, 1 << 24);
dis[id[s]] = 0;
int cal_dis[10000 + 5];
fill(cal_dis, cal_dis + 10000 + 5, -1);
cal_dis[s] = 0;
queue<int> que;
que.push(s);
while (!que.empty()) {
int cur = que.front();
que.pop();
for (int i = 0; i < L; ++i) {
int v = cur + a[i];
if (v >= N || v == s || cal_dis[v] != -1) continue;
cal_dis[v] = cal_dis[cur] + 1;
if (panel[v] == 1) {
dis[id[v]] = cal_dis[v];
} else {
que.push(v);
}
}
for (int i = 0; i < L; ++i) {
int v = cur - a[i];
if (v < 0 || v == s || cal_dis[v] != -1) continue;
cal_dis[v] = cal_dis[cur] + 1;
if (panel[v] == 1) {
dis[id[v]] = cal_dis[v];
} else {
que.push(v);
}
}
}
}
int dp[1 << 24];
int main() {
int N, K, L;
bitset<10000 + 5> panel;
int x[10 + 5], a[100 + 5];
cin >> N >> K >> L;
for (int i = 0; i < K; ++i) {
cin >> x[i];
panel[x[i]] = 1;
}
for (int i = 0; i < L; ++i) {
cin >> a[i];
}
panel = panel ^ (panel >> 1);
vector<int> vertices;
int dis[24][24];
int id[10000 + 5];
int size = 0;
for (int i = 0; i < N + 1; ++i) {
if (panel[i] == 1) {
id[i] = size++;
}
}
for (int i = 0; i < N + 1; ++i) {
if (panel[i] == 1) {
bfs(i, panel, dis[id[i]], a, L, N + 1, id, size);
}
}
int mask = 1 << size;
fill(dp, dp + mask, 1 << 24);
dp[0] = 0;
for (int i = 3; i < mask; ++i) {
for (int k = 0; k < size; ++k) {
if (i & (1 << k)) {
for (int j = k + 1; j < size; ++j) {
if (i & (1 << j)) {
int p = i - (1 << k) - (1 << j);
if (dp[p] < (1 << 24) && dis[k][j] < (1 << 24)) {
dp[i] = min(dp[i], dp[p] + dis[k][j]);
}
}
}
break;
}
}
}
if (dp[mask - 1] < 1 << 24)
cout << dp[mask - 1] << endl;
else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct IO {
char buf[(1 << 20)], *p1, *p2;
char pbuf[(1 << 20)], *pp;
IO() : p1(buf), p2(buf), pp(pbuf) {}
inline char gc() {
return getchar();
if (p1 == p2) p2 = (p1 = buf) + fread(buf, 1, (1 << 20), stdin);
return p1 == p2 ? ' ' : *p1++;
}
inline bool blank(char ch) {
return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
template <class T>
inline void read(T &x) {
register double tmp = 1;
register bool sign = 0;
x = 0;
register char ch = gc();
for (; !(ch >= '0' && ch <= '9'); ch = gc())
if (ch == '-') sign = 1;
for (; (ch >= '0' && ch <= '9'); ch = gc()) x = x * 10 + (ch - '0');
if (ch == '.')
for (ch = gc(); (ch >= '0' && ch <= '9'); ch = gc())
tmp /= 10.0, x += tmp * (ch - '0');
if (sign) x = -x;
}
inline void read(char *s) {
register char ch = gc();
for (; blank(ch); ch = gc())
;
for (; !blank(ch); ch = gc()) *s++ = ch;
*s = 0;
}
inline void read(char &c) {
for (c = gc(); blank(c); c = gc())
;
}
template <class t>
inline void write(t x) {
if (x < 0)
putchar('-'), write(-x);
else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
} io;
const int mod = 1e9 + 7;
const int mo = 998244353;
const int N = 1e4 + 5;
const int M = 1 << 20 | 1;
int n, m, s, l[N], f[M], d[21][21], cf[N], id[N], dis[N], vis[N], ans, gs;
inline void bfs(int x) {
for (int i = (1); i <= (n + 1); i++) dis[i] = 1e9, vis[i] = 0;
dis[x] = 0;
queue<int> q;
q.push(x);
while (!q.empty()) {
int u = q.front();
q.pop();
vis[u] = 0;
for (int i = (1); i <= (s); i++) {
int v = u - l[i];
if (v >= 1 && dis[v] > dis[u] + 1) {
dis[v] = dis[u] + 1;
if (!vis[v]) vis[v] = 1, q.push(v);
}
v = u + l[i];
if (v <= n + 1 && dis[v] > dis[u] + 1) {
dis[v] = dis[u] + 1;
if (!vis[v]) vis[v] = 1, q.push(v);
}
}
}
for (int i = (1); i <= (n + 1); i++)
if (cf[i]) d[id[x]][id[i]] = d[id[i]][id[x]] = dis[i];
}
int main() {
io.read(n), io.read(m), io.read(s);
for (int i = (1); i <= (m); i++) {
int place;
io.read(place);
cf[place] = 1;
}
for (int i = (1); i <= (s); i++) io.read(l[i]);
for (int i = (n + 1); i >= (1); i--) cf[i] ^= cf[i - 1];
for (int i = (1); i <= (n + 1); i++)
if (cf[i]) id[i] = ++gs;
for (int i = (1); i <= (n + 1); i++)
if (cf[i]) bfs(i);
memset(f, 127 / 3, sizeof(f)), f[0] = 0;
int mx = f[1];
int MS = (1 << gs) - 1;
for (int S = (0); S <= (MS); S++)
for (int i = (1); i <= (gs); i++)
if (S & (1 << i - 1))
for (int j = (i + 1); j <= (gs); j++)
if (S & (1 << j - 1))
f[S] = min(f[S], f[S ^ (1 << i - 1) ^ (1 << j - 1)] + d[i][j]);
io.write((f[MS] == mx) ? -1 : f[MS]), puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10005;
int n, k, m, a[MAXN], s[MAXN], sum, num[MAXN];
int v[MAXN], d[MAXN], dist[25][25], f[1 << 21];
queue<int> q;
void bfs(int x, int id) {
memset(v, 0, sizeof(v));
memset(d, 0x3f, sizeof(d));
q.push(x);
v[x] = 1;
d[x] = 0;
while (!q.empty()) {
x = q.front();
q.pop();
for (int i = 1; i <= m; i++) {
int t = s[i];
if (x + t <= n && !v[x + t])
v[x + t] = 1, d[x + t] = d[x] + 1, q.push(x + t);
if (x - t >= 1 && !v[x - t])
v[x - t] = 1, d[x - t] = d[x] + 1, q.push(x - t);
}
}
for (int i = 1; i <= sum; i++)
if (v[num[i]])
dist[id][i] = d[num[i]];
else
dist[id][i] = 1e9;
}
int main() {
scanf("%d%d%d", &n, &k, &m);
for (int i = 1; i <= k; i++) {
int x;
scanf("%d", &x);
a[x] = 1;
}
for (int i = 1; i <= m; i++) scanf("%d", &s[i]);
n++;
for (int i = n; i >= 1; i--) a[i] ^= a[i - 1];
for (int i = 1; i <= n; i++)
if (a[i]) a[i] = ++sum, num[sum] = i;
for (int i = 1; i <= n; i++)
if (a[i]) bfs(i, a[i]);
for (int i = 1; i < (1 << sum); i++) f[i] = 1e9;
for (int i = 0; i < (1 << sum); i++) {
int j = 0;
for (int k = 1; k <= sum && j == 0; k++)
if ((1 << k - 1) & i) j = k;
for (int k = 1; k <= sum; k++)
if ((1 << k - 1) & i)
f[i] = min(f[i], f[i ^ (1 << j - 1) ^ (1 << k - 1)] + dist[j][k]);
}
printf("%d", f[(1 << sum) - 1] >= 1e9 ? -1 : f[(1 << sum) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, l, a[10010], b[10010], t[110];
int moves[25][25], dp[1 << 20], ans[10010];
queue<pair<int, int> > Q;
int tot, cnt;
int pos[25];
void bfs(int st) {
for (int i = 0; i <= n; i++) ans[i] = 1e9;
while (!Q.empty()) Q.pop();
Q.push(make_pair(st, 0));
while (!Q.empty()) {
pair<int, int> now = Q.front();
Q.pop();
if (ans[now.first] <= now.second) continue;
ans[now.first] = now.second;
for (int i = 1; i <= l; i++) {
if (now.first - t[i] >= 0)
Q.push(make_pair(now.first - t[i], now.second + 1));
if (now.first + t[i] <= n)
Q.push(make_pair(now.first + t[i], now.second + 1));
}
}
}
void init() {
cnt = 0;
for (int i = 0; i <= n; i++)
if (b[i] == 1) pos[cnt++] = i;
tot = (1 << cnt);
for (int i = 0; i < cnt; i++) {
bfs(pos[i]);
for (int j = i + 1; j < cnt; j++) moves[i][j] = ans[pos[j]];
}
}
void getdp() {
dp[0] = 0;
for (int i = 1; i < tot; i++) dp[i] = 1e9;
for (int S = 0; S < tot; S++) {
if (dp[S] == 1e9) continue;
for (int p1 = 0; p1 < cnt; p1++) {
if (S & (1 << p1)) continue;
for (int p2 = p1 + 1; p2 < cnt; p2++) {
if (S & (1 << p2)) continue;
int nS = ((S | (1 << p1)) | (1 << p2));
if (dp[S] + moves[p1][p2] < dp[nS]) dp[nS] = dp[S] + moves[p1][p2];
}
}
}
}
int main() {
cin >> n >> k >> l;
for (int i = 1; i <= k; i++) {
int x;
cin >> x;
a[x] = 1;
}
for (int i = 0; i <= n; i++) b[i] = (a[i] ^ a[i + 1]);
for (int i = 1; i <= l; i++) {
cin >> t[i];
Q.push(make_pair(t[i], 1));
}
init();
getdp();
if (dp[tot - 1] == 1e9)
cout << -1 << endl;
else
cout << dp[tot - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long min(long long x, long long y) { return x < y ? x : y; }
inline long long max(long long x, long long y) { return x > y ? x : y; }
const int Maxn = 1e4 + 5;
int n, k, m, ans = -1;
int a[Maxn], b[105], c[30], dis[30][Maxn], f[2000005], pw[30];
bool inq[Maxn];
void SPFA(register int x, register int p) {
dis[p][x] = 0;
queue<int> q;
q.push(x);
while (!q.empty()) {
x = q.front();
q.pop();
inq[x] = false;
for (register int i = 1, nx; i <= m; i++) {
nx = x + b[i];
if (nx <= n + 1)
if (dis[p][x] + 1 < dis[p][nx]) {
dis[p][nx] = dis[p][x] + 1;
if (!inq[nx]) {
q.push(nx);
inq[nx] = true;
}
}
nx = x - b[i];
if (nx > 0)
if (dis[p][x] + 1 < dis[p][nx]) {
dis[p][nx] = dis[p][x] + 1;
if (!inq[nx]) {
q.push(nx);
inq[nx] = true;
}
}
}
}
}
int main() {
pw[0] = 1;
for (int i = 1; i <= 25; i++) pw[i] = pw[i - 1] << 1;
memset(dis, 0x3f, sizeof(dis));
int pos, siz = 0;
cin >> n >> k >> m;
for (int i = 1; i <= k; i++) {
scanf("%d", &pos);
a[pos] = 1;
}
for (int i = 1; i <= m; i++) scanf("%d", &b[i]);
for (int i = 0; i <= n; i++)
if (a[i + 1] != a[i]) {
c[++siz] = i + 1;
SPFA(i + 1, siz);
}
n = siz;
memset(f, 0x3f, sizeof(f));
f[0] = 0;
int nx;
for (int i = 0; i < pw[n] - 3; i++)
for (int j = 1; j < n; j++)
for (int k = j + 1; k <= n; k++) {
if ((i & pw[j - 1]) || (i & pw[k - 1])) continue;
nx = i | pw[j - 1] | pw[k - 1];
f[nx] = min(f[nx], f[i] + dis[j][c[k]]);
}
if (f[pw[n] - 1] == 0x3f3f3f3f) f[pw[n] - 1] = -1;
cout << f[pw[n] - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, l;
scanf("%d%d%d", &n, &k, &l);
vector<int> x0(k), x;
for (auto &i : x0) {
scanf("%d", &i);
}
sort(x0.begin(), x0.end());
k = unique(x0.begin(), x0.end()) - x0.begin();
x0.resize(k);
for (int i = 0; i < k; ++i) {
if (i == 0 || x0[i] != x0[i - 1] + 1) {
x.push_back(x0[i] - 1);
}
if (i == k - 1 || x0[i] != x0[i + 1] - 1) {
x.push_back(x0[i]);
}
}
sort(x.begin(), x.end());
vector<int> a(l);
for (auto &i : a) {
scanf("%d", &i);
}
k = (int)x.size();
vector<vector<int>> f(k);
for (int i = 0; i < k; ++i) {
f[i].assign(n + 1, -1);
f[i][x[i]] = 0;
queue<int> q;
q.push(x[i]);
for (; q.size() > 0;) {
int u = q.front();
q.pop();
for (auto j : a) {
if (u + j <= n && f[i][u + j] == -1) {
f[i][u + j] = f[i][u] + 1;
q.push(u + j);
}
if (u - j >= 0 && f[i][u - j] == -1) {
f[i][u - j] = f[i][u] + 1;
q.push(u - j);
}
}
}
}
vector<int> dp(1 << k, -1);
dp[0] = 0;
for (int s = 0; s + 1 < (1 << k); ++s) {
if (dp[s] == -1) {
continue;
}
int i;
for (i = 0; i < k; ++i) {
if ((s & (1 << i)) == 0) {
break;
}
}
for (int j = i + 1; j < k; ++j) {
if ((s & (1 << j)) == 0 && f[i][x[j]] != -1 &&
(dp[s ^ (1 << i) ^ (1 << j)] == -1 ||
dp[s ^ (1 << i) ^ (1 << j)] > dp[s] + f[i][x[j]])) {
dp[s ^ (1 << i) ^ (1 << j)] = dp[s] + f[i][x[j]];
}
}
}
printf("%d\n", dp[(1 << k) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
template <typename Tp>
inline void read(Tp &x) {
x = 0;
bool f = true;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar()) f ^= ch == '-';
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + (ch ^ 48);
x = f ? x : -x;
}
const int N = 25, M = 1e4 + 7, K = 1 << 20, L = 105;
int a[M], cnt = 0, num[N], dis[N][N], f[K], d[M], l, len[L], n, k, tot[K];
std::queue<int> q;
inline void bfs(int s) {
std::memset(d, 0x3f3f3f3f, sizeof(d));
d[num[s]] = 0, q.push(num[s]);
while (q.size()) {
int x = q.front();
q.pop();
for (int i = 1; i <= l; ++i) {
if (x > len[i] && d[x - len[i]] > d[x] + 1) {
d[x - len[i]] = d[x] + 1;
q.push(x - len[i]);
}
if (x + len[i] <= n + 1 && d[x + len[i]] > d[x] + 1) {
d[x + len[i]] = d[x] + 1;
q.push(x + len[i]);
}
}
}
for (int i = 1; i <= cnt; ++i) dis[s][i] = d[num[i]];
}
int main() {
read(n), read(k), read(l);
for (int i = 1; i <= k; ++i) {
int x;
read(x);
a[x] ^= 1;
}
for (int i = 1; i <= n + 1; ++i) {
if (a[i] != a[i - 1]) num[++cnt] = i;
}
for (int i = 1; i <= l; ++i) read(len[i]);
for (int i = 1; i <= cnt; ++i) bfs(i);
for (int i = 1; i < (1 << cnt); ++i) tot[i] = tot[i ^ (i & (-i))] + 1;
std::memset(f, 0x3f3f3f3f, sizeof(f));
f[0] = 0;
for (int i = 0; i < (1 << cnt); ++i) {
if (f[i] == 0x3f3f3f3f) continue;
int x = 0;
for (; (i & (1 << x)); ++x)
;
for (int j = x + 1; j < cnt; ++j) {
if (i & (1 << j)) continue;
f[i | (1 << x) | (1 << j)] =
std::min(f[i | (1 << x) | (1 << j)], f[i] + dis[x + 1][j + 1]);
}
}
printf("%d\n", f[(1 << cnt) - 1] == 0x3f3f3f3f ? -1 : f[(1 << cnt) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10010;
const int inf = 0x3fffffff;
int dp[1 << 20], w[20][20], d[maxn], x[20], a[100];
inline int rightZeroBit(int mask) {
for (int i = 0;; i++) {
if ((mask & (1 << i)) == 0) return i;
}
return -1;
}
int main() {
int n, k, l;
while (scanf("%d%d%d", &n, &k, &l) == 3) {
for (int i = 0; i < k; i++) scanf("%d", &x[i]);
for (int i = 0; i < l; i++) scanf("%d", &a[i]);
sort(a, a + l);
l = unique(a, a + l) - a;
set<int> iset;
for (int i = 0; i < k; i++) {
pair<set<int>::iterator, bool> p;
p = iset.insert(x[i] - 1);
if (!p.second) iset.erase(p.first);
p = iset.insert(x[i]);
if (!p.second) iset.erase(p.first);
}
k = copy(iset.begin(), iset.end(), x) - x;
for (int i = 0; i < k; i++) {
fill(d, d + n + 1, inf);
d[x[i]] = 0;
priority_queue<pair<int, int> > pq;
pq.push(make_pair(0, x[i]));
while (!pq.empty()) {
int s = pq.top().second;
int t = -pq.top().first;
pq.pop();
if (d[s] != t) continue;
for (int j = 0; j < l; j++) {
if (s - a[j] >= 0 && d[s - a[j]] > t + 1) {
d[s - a[j]] = t + 1;
pq.push(make_pair(-d[s - a[j]], s - a[j]));
}
if (s + a[j] <= n && d[s + a[j]] > t + 1) {
d[s + a[j]] = t + 1;
pq.push(make_pair(-d[s + a[j]], s + a[j]));
}
}
}
for (int j = 0; j < k; j++) w[i][j] = d[x[j]];
}
fill(dp, dp + (1 << k), inf);
dp[0] = 0;
for (int mask = 0; mask < (1 << k); mask++) {
int u;
for (u = 0; u < k; u++)
if ((mask & (1 << u)) == 0) break;
if (u >= k) continue;
for (int v = u + 1; v < k; v++)
if ((mask & (1 << v)) == 0) {
int _mask = mask ^ (1 << u) ^ (1 << v);
dp[_mask] = min(dp[_mask], dp[mask] + w[u][v]);
}
}
printf("%d\n", dp[(1 << k) - 1] == inf ? -1 : dp[(1 << k) - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e4 + 10;
struct Edge {
int to, nxt;
} e[6000010];
int h[N], idx;
void Ins(int a, int b) {
e[++idx].to = b;
e[idx].nxt = h[a];
h[a] = idx;
}
int a[N], que[N], tt, dis[N], n, m, pos[N];
bool inq[N];
void bfs(int s) {
memset(dis, 0x3f, sizeof(dis));
memset(inq, 0, sizeof(inq));
queue<int> q;
q.push(s);
dis[s] = 0;
inq[s] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 1; i <= m; i++) {
const int d = pos[i];
if (u + d <= n + 1 && (!inq[u + d])) {
dis[u + d] = dis[u] + 1;
q.push(u + d);
inq[u + d] = 1;
}
if (u - d > 0 && (!inq[u - d])) {
dis[u - d] = dis[u] + 1;
q.push(u - d);
inq[u - d] = 1;
}
}
}
}
int cnt[N], res, clo;
long long f[1 << 20], mp[110][110];
void dfs(int u, int s) {
if (s > res) return;
if (u == tt) {
for (int i = 1; i < tt; i++)
if (!(cnt[i] & 1)) return;
res = min(res, s);
return;
}
clo++;
if (clo >= 6000000) {
printf("%d\n", res);
exit(0);
}
for (int i = 1; i <= tt; i++) {
cnt[u]++;
cnt[i]++;
dfs(u + 1, s + mp[u][i]);
cnt[u]--;
cnt[i]--;
}
}
int main() {
int k;
scanf("%d%d%d", &n, &k, &m);
for (int i = 1; i <= k; i++) {
int x;
scanf("%d", &x);
a[x] = 1;
}
for (int i = 1; i <= n + 1; i++)
if (a[i] ^ a[i - 1]) que[++tt] = i;
for (int i = 1; i <= m; i++) scanf("%d", &pos[i]);
for (int i = 1; i <= tt; i++) {
bfs(que[i]);
for (int j = 1; j <= tt; j++) {
mp[i][j] = dis[que[j]];
}
}
int Mx = 1 << tt;
for (int i = 1; i <= Mx; i++) f[i] = 1e9;
for (register int i = 0; i < Mx; i++) {
int j = 1;
while (i & (1 << j - 1)) j++;
for (register int c = j + 1; c <= tt; c++) {
if (i & (1 << c - 1)) continue;
f[i | (1 << c - 1) | (1 << j - 1)] =
min(f[i | (1 << c - 1) | (1 << j - 1)], f[i] + mp[c][j]);
}
}
printf("%lld\n", f[Mx - 1] == 1e9 ? -1 : f[Mx - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
const int P = 1048576 + 10;
const int Y = 30;
int tr[N];
int cnt;
int cf[N];
int a[N];
int n;
int m;
int k;
int cst[Y][Y];
int d[N];
int dp[P];
queue<int> q;
inline void bfs(int s) {
for (int i = 1; i <= n + 1; i++) d[i] = 0x3f3f3f3f;
d[s] = 0;
int nw;
int i = 1;
for (q.push(s); !q.empty();)
for (nw = q.front(), q.pop(), i = 1; i <= m; i++) {
int v1 = nw + a[i];
if (v1 <= n + 1 && d[v1] == 0x3f3f3f3f) d[v1] = d[nw] + 1, q.push(v1);
int v2 = nw - a[i];
if (v2 >= 1 && d[v2] == 0x3f3f3f3f) d[v2] = d[nw] + 1, q.push(v2);
}
for (int i = 1; i <= n + 1; i++)
if (tr[i] != -1) cst[tr[s]][tr[i]] = d[i];
}
int main() {
scanf("%d%d%d", &n, &k, &m);
for (int i = 1, t; i <= k; i++) {
scanf("%d", &t);
cf[t] = 1;
}
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
for (int i = n + 1; i >= 1; i--) cf[i] ^= cf[i - 1];
cnt = -1;
for (int i = 1; i <= n + 1; i++) tr[i] = -1;
for (int i = 1; i <= n + 1; i++)
if (cf[i]) tr[i] = ++cnt;
for (int i = 1; i <= n + 1; i++)
if (cf[i]) bfs(i);
for (int i = 1; i < (1 << (cnt + 1)); i++) dp[i] = 0x3f3f3f3f;
for (int i = 0; i < (1 << (cnt + 1)); i++) {
if (dp[i] == 0x3f3f3f3f) continue;
for (int j = 0; j <= cnt; j++) {
if ((i >> j) & 1) continue;
for (int k = j + 1; k <= cnt; k++)
if (((i >> k) & 1) == 0)
dp[i + (1 << j) + (1 << k)] =
min(dp[i + (1 << j) + (1 << k)], dp[i] + cst[j][k]);
}
}
int ans = dp[(1 << (cnt + 1)) - 1];
printf("%d", (ans == 0x3f3f3f3f) ? -1 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10010;
const int inf = 0x3fffffff;
int d[maxn], x[20], a[100], dp[1 << 20], w[20][20];
bool vis[maxn];
int main() {
int n, k, l;
while (scanf("%d%d%d", &n, &k, &l) == 3) {
memset(vis, 0, sizeof(vis));
for (int i = 0; i < k; i++) scanf("%d", &x[i]), vis[x[i]] = 1;
for (int i = 0; i < l; i++) scanf("%d", &a[i]);
sort(a, a + l);
l = unique(a, a + l) - a;
k = 0;
for (int i = 0; i <= n; i++)
if (vis[i] != vis[i + 1]) x[k++] = i;
for (int i = 0; i < k; i++) {
priority_queue<pair<int, int> > q;
fill(d, d + n + 1, inf);
d[x[i]] = 0;
for (q.push(make_pair(0, x[i])); !q.empty();) {
int u = q.top().second;
int dis = -q.top().first;
q.pop();
if (d[u] != dis) continue;
for (int j = 0; j < l; j++) {
if (u - a[j] >= 0 && d[u - a[j]] > dis + 1)
d[u - a[j]] = dis + 1, q.push(make_pair(-dis - 1, u - a[j]));
if (u + a[j] <= n && d[u + a[j]] > dis + 1)
d[u + a[j]] = dis + 1, q.push(make_pair(-dis - 1, u + a[j]));
}
}
for (int j = 0; j < k; j++) w[i][j] = d[x[j]];
}
fill(dp, dp + (1 << k), inf);
dp[0] = 0;
for (int mask = 0; mask < (1 << k); mask++) {
int u;
for (u = 0; u < k; u++)
if ((mask & (1 << u)) == 0) break;
if (u >= k) continue;
for (int v = u + 1; v < k; v++)
if ((mask & (1 << v)) == 0) {
int _mask = mask ^ (1 << u) ^ (1 << v);
dp[_mask] = min(dp[_mask], dp[mask] + w[u][v]);
}
}
printf("%d\n", dp[(1 << k) - 1] == inf ? -1 : dp[(1 << k) - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int c, v0, v1, a, l;
cin >> c >> v0 >> v1 >> a >> l;
int ans = 1, t = 0, s = v0;
t += s;
while (t < c) {
t -= l;
if (s + a > v1)
s = v1;
else
s += a;
t += s;
ans++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int xx, int yy) {
while (yy != 0) {
xx = xx % yy;
swap(xx, yy);
}
return xx;
}
int lcm(int xx, int yy) { return (xx / gcd(xx, yy)) * yy; }
int c, v0, v1, a, l;
int main() {
cin >> c >> v0 >> v1 >> a >> l;
int res = 0;
int idx = 0;
c -= v0;
res += 1;
while (c > 0) {
idx += 1;
int tmp = min(v1, v0 + a * idx) - l;
res += 1;
c -= tmp;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int c, v0, v1, a, l, cnt = 0, g = 0;
scanf("%d%d%d%d%d", &c, &v0, &v1, &a, &l);
for (int i = 1; i <= 1000; i++) {
cnt += ((v0 + (a * (i - 1)) > v1) ? v1 : v0 + (a * (i - 1)));
if (cnt >= c) return printf("%d", i), 0;
cnt -= l;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, v, vm, l, c;
cin >> c >> v >> vm >> a >> l;
int cou = 0, r = 0;
while (r < c) {
cou++;
r += v;
if (r == v) v -= l;
v += a;
if (v > vm - l) v = vm - l;
}
cout << cou << endl;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:10240000")
using namespace std;
int main() {
int c, v0, v1, a, l;
scanf("%d%d%d%d%d", &c, &v0, &v1, &a, &l);
int ans = 0;
if (v0 >= c) {
ans = 1;
} else {
int sp = v0, now = v0, num = 1;
while (sp < v1) {
sp += a;
if (sp >= v1) {
sp = v1;
}
now += sp - l;
num++;
if (now >= c) {
ans = num;
break;
}
}
if (!ans) {
int tmp = c - now;
ans = tmp / (v1 - l);
if (tmp % (v1 - l)) {
ans++;
}
ans += num;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int c, v0, v1, a, l;
scanf("%d %d %d %d %d", &c, &v0, &v1, &a, &l);
int day = 1;
int v = v0;
while (1) {
c -= v;
if (c <= 0) {
break;
}
v = v + a;
if (v > v1) v = v1;
c += l;
day++;
}
printf("%d\n", day);
return 0;
}
|
#include <bits/stdc++.h>
int main(void) {
int c, vmin, vmax, a, re;
int v, day;
int i, j, k;
scanf("%d%d%d%d%d", &c, &vmin, &vmax, &a, &re);
v = vmin;
day = 1;
while (c > v) {
if (c <= v) break;
c -= v;
v += a;
if (v > vmax) v = vmax;
c += re;
day++;
}
printf("%d\n", day);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
long long power(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b & 1) ans *= a;
a = a * a;
b >>= 1;
}
return ans;
}
long long powm(long long a, long long b) {
a %= MOD;
long long ans = 1;
while (b > 0) {
if (b & 1) ans = (ans * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return ans;
}
void IO() {}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
IO();
;
int c, v0, v1, a, l;
cin >> c >> v0 >> v1 >> a >> l;
int ans = 0;
while (c > 0) {
if (ans == 0)
c -= v0;
else
c -= min(v0 + ans * a - l, v1 - l);
ans++;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long c, v0, v1, a, l;
cin >> c >> v0 >> v1 >> a >> l;
long long d = v0;
long long cnt = 1;
long long i = 1;
while (d < c) {
d += min(v1, i * a + v0) - l;
i++;
cnt++;
}
cout << cnt;
}
|
#include <bits/stdc++.h>
using namespace std;
int c, v0, v1, a, l;
inline long long solve();
int main() {
cin >> c >> v0 >> v1 >> a >> l;
int ans = solve();
cout << ans << endl;
return 0;
}
inline long long solve() {
if (c <= v0) return 1;
int now = v0;
int nows = v0 + a;
int cont = 1;
while (now < c) {
if (nows > v1) {
nows = v1;
}
now += nows - l;
nows += a;
cont++;
}
return cont;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned int c, l, v0, v1, a;
cin >> c >> v0 >> v1 >> a >> l;
int days = 0;
int day_last_page = 0;
while (day_last_page < c) {
days++;
int day_start = day_last_page - l;
if (day_start < 0) day_start = 0;
int day_speed = v0 + a * (days - 1);
if (day_speed > v1) day_speed = v1;
day_last_page = day_start + day_speed;
}
cout << days;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int c, v0, v1, a, l;
scanf("%d %d %d %d %d", &c, &v0, &v1, &a, &l);
int sum = 0;
int day = 0;
int k = v0;
while (sum < c) {
if (day == 0) {
sum += k;
} else
sum = sum + k - l;
k += a;
if (k > v1) k = v1;
day++;
}
printf("%d\n", day);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 5 * 1e5 + 100;
const long int INF = 1e7 + 1;
long c, v0, v1, l, days = 0, s;
long a;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> c >> v0 >> v1 >> a >> l;
long long ans = 0;
if (v0 >= c) {
cout << 1;
return 0;
}
int s = v0;
days++;
ans += s;
while (ans < c) {
ans -= l;
days++;
s = min(s + a, v1);
ans += s;
}
cout << days;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
;
long long int c, vo, vl, a, l;
cin >> c >> vo >> vl >> a >> l;
long long int ctr = 0, day = 0;
while (ctr < c) {
ctr += min(vl, vo) - min(l, ctr);
vo += a;
day++;
}
cout << day << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.