text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 210;
const int M = 1 << 7;
const int INF = 0x3f3f3f3f;
const int iinf = 1 << 30;
const long long linf = 2e18;
const int MOD = 1000000007;
const double eps = 1e-7;
void print(int x) {
cout << x << endl;
exit(0);
}
void PRINT(string x) {
cout << x << endl;
exit(0);
}
void douout(double x) { printf("%lf\n", x + 0.0000000001); }
int dp[N][M], pre[N][M], vis[N][M];
int hsh[N], maz[N][N];
char g[N][N];
int n, m, k, nn, mm;
int dx[] = {0, 0, -1, 1};
int dy[] = {-1, 1, 0, 0};
struct node {
int x, dis;
};
queue<node> q;
void modify(int x, int dis, int w, int fa) {
if (dp[x][dis] > w) {
dp[x][dis] = w;
pre[x][dis] = fa;
if (!vis[x][dis]) {
q.push((node){x, dis});
vis[x][dis] = 1;
}
}
}
void dfs(int X, int dis) {
int x = X / m, y = X % m;
g[x][y] = 'X';
if (pre[X][dis] == -1) return;
int to = pre[X][dis] / 1000, diss = pre[X][dis] % 1000;
dfs(to, diss);
if (diss - dis) dfs(to, dis - diss);
}
bool check(int x, int y) {
if (x >= 0 && x < n && y >= 0 && y < m) return true;
return false;
}
void getans() {
while (!q.empty()) {
node nw = q.front();
q.pop();
int now = nw.x, x = nw.x / m, y = nw.x % m, dis = nw.dis;
vis[now][dis] = false;
for (int i = (0); i <= (3); i++) {
int tx = x + dx[i], ty = y + dy[i];
if (!check(tx, ty)) continue;
int to = tx * m + ty;
modify(to, dis, dp[now][dis] + maz[tx][ty], now * 1000 + dis);
}
int t = mm - dis - 1;
for (int i = t; i; i = (i - 1) & t) {
modify(now, i | dis, dp[now][i] + dp[now][dis] - maz[x][y],
now * 1000 + dis);
}
}
int ans = iinf, now;
for (int i = (0); i <= (nn - 1); i++)
if (ans > dp[i][mm - 1]) {
ans = dp[i][mm - 1];
now = i;
}
dfs(now, mm - 1);
printf("%d\n", ans);
for (int i = (0); i <= (n - 1); i++) {
for (int j = (0); j <= (m - 1); j++) cout << g[i][j];
cout << endl;
}
}
signed main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = (0); i <= (n - 1); i++) {
for (int j = (0); j <= (m - 1); j++) {
scanf("%d", &maz[i][j]);
g[i][j] = '.';
}
}
nn = n * m;
mm = (1 << k);
memset(hsh, 0, sizeof(hsh));
memset(vis, 0, sizeof(vis));
for (int i = (0); i <= (nn - 1); i++)
for (int j = (0); j <= (mm - 1); j++) dp[i][j] = iinf;
for (int i = (0); i <= (k - 1); i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
int id = a * m + b;
hsh[id] = 1 << i;
modify(id, hsh[id], maz[a][b], -1);
}
getans();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Nmax = 205, Kmax = 105, Pmax = 7, Inf = 0x3f3f3f3f;
const int dx[] = {-1, 0, 1, 0}, dy[] = {0, -1, 0, 1};
int A[Kmax][Kmax];
char B[Kmax][Kmax];
vector<int> G[Nmax];
int N, M, P;
int cost[Nmax];
int dist[Nmax][Nmax], from[Nmax][Nmax];
int dp[1 << Pmax][Nmax], pprev[1 << Pmax][Nmax];
bool typer[1 << Pmax][Nmax];
vector<int> specials;
int posSp[Nmax];
bool inQueue[Nmax];
inline int getkey(int x, int y) { return (x - 1) * M + y; }
inline pair<int, int> getcell(int x) {
return make_pair((x - 1) / M + 1, (x - 1) % M + 1);
}
inline void mark(int x) {
pair<int, int> cell = getcell(x);
B[cell.first][cell.second] = 'X';
}
void getDist(int dist[], int from[], int S) {
from[S] = -1;
memset(dist, Inf, sizeof(int) * Nmax);
dist[S] = cost[S];
queue<int> Q;
Q.push(S);
while (!Q.empty()) {
int node = Q.front();
Q.pop();
inQueue[node] = false;
for (int p : G[node]) {
if (dist[p] > dist[node] + cost[p]) {
dist[p] = dist[node] + cost[p];
from[p] = node;
if (!inQueue[p]) {
Q.push(p);
inQueue[p] = true;
}
}
}
}
}
int getAns(int conf, int node) {
int &ans = dp[conf][node];
if (ans != -1) return ans;
if (conf == 0) return ans = cost[node];
if (posSp[node] != 0) {
int x = posSp[node] - 1;
if (conf == (1 << x)) return ans = cost[node];
}
ans = Inf;
for (int nconf = (conf - 1) & conf; nconf > 0; nconf = (nconf - 1) & conf) {
int ccost = getAns(nconf, node) + getAns(conf ^ nconf, node) - cost[node];
if (ccost < ans) {
ans = ccost;
typer[conf][node] = false;
pprev[conf][node] = nconf;
}
}
for (int i = 1; i <= N * M; ++i) {
if (i == node) continue;
int ccost = getAns(conf, i) + dist[i][node] - cost[i];
if (ccost < ans) {
ans = ccost;
typer[conf][node] = true;
pprev[conf][node] = i;
}
}
return ans;
}
void fillMatrix(int conf, int node) {
mark(node);
if ((posSp[node] != 0 && conf == (1 << posSp[node] - 1)) || conf == 0) return;
if (typer[conf][node]) {
int x = pprev[conf][node];
for (int i = node; i != x; i = from[x][i]) mark(i);
fillMatrix(conf, x);
} else {
int x = pprev[conf][node];
fillMatrix(x, node);
fillMatrix(conf ^ x, node);
}
}
int main() {
ios::sync_with_stdio(false);
cin >> N >> M >> P;
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= M; ++j) cin >> A[i][j];
for (int i = 1; i <= N; ++i) {
for (int j = 1; j <= M; ++j) {
int k1 = getkey(i, j);
cost[k1] = A[i][j];
for (int k = 0; k < 4; ++k) {
int nx = i + dx[k], ny = j + dy[k];
if (nx < 1 || nx > N || ny < 1 || ny > M) continue;
int k2 = getkey(nx, ny);
G[k1].push_back(k2);
}
}
}
for (int i = 1; i <= N * M; ++i) {
getDist(dist[i], from[i], i);
}
for (int i = 0; i < P; ++i) {
int x, y;
cin >> x >> y;
int k = getkey(x, y);
posSp[k] = i + 1;
specials.push_back(k);
}
memset(dp, -1, sizeof dp);
int ans = Inf, conf = (1 << P) - 1, node = 0;
for (int i = 1; i <= N * M; ++i) {
int cost = getAns(conf, i);
if (cost < ans) {
ans = cost;
node = i;
}
}
for (int i = 1; i <= N; ++i) {
for (int j = 1; j <= M; ++j) {
B[i][j] = '.';
}
}
fillMatrix(conf, node);
cout << ans << '\n';
for (int i = 1; i <= N; ++i) cout << (B[i] + 1) << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200 + 50;
const int MAXV = 40000 + 50;
const int MAXQ = 1000000 + 50;
const int sigma_size = 26;
const int inf = 0x3f3f3f3f;
const int INF = ~0U >> 1;
const int IMIN = 0x80000000;
const long long MOD = 1000000000 + 7;
const int mod = 10007;
const double PI = acos(-1.0);
int n, m, k;
queue<int> q;
int bit[MAXN];
int head[MAXN];
int dp[MAXN][1 << 8];
int in[MAXN][1 << 8];
int pre[MAXN][1 << 8];
int val[MAXN];
int vis[MAXN];
int u, v;
struct Edge {
int v, next;
} e[MAXV];
int num;
void adde(int u, int v) {
e[num].v = v;
e[num].next = head[u];
head[u] = num++;
}
void init() {
num = 0;
memset(head, -1, sizeof(head));
memset(dp, 0x3f, sizeof(dp));
memset(pre, 0, sizeof(pre));
memset(bit, 0, sizeof(bit));
memset(vis, 0, sizeof(vis));
memset(in, 0, sizeof(in));
while (!q.empty()) q.pop();
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int cnt = i * m + j;
scanf("%d", &val[i * m + j]);
if (i > 0) adde(cnt, cnt - m);
if (i < n - 1) adde(cnt, cnt + m);
if (j > 0) adde(cnt, cnt - 1);
if (j < m - 1) adde(cnt, cnt + 1);
}
}
for (int i = 0; i < k; i++) {
scanf("%d%d", &u, &v);
u--, v--;
int cnt = u * m + v;
bit[cnt] = 1 << i;
dp[cnt][bit[cnt]] = val[cnt];
}
}
void spfa() {
while (!q.empty()) {
int x = q.front() & 1023, st = q.front() >> 10;
in[x][st] = 0;
q.pop();
for (int j = head[x]; j != -1; j = e[j].next) {
int y = e[j].v, nst = st | bit[y];
if (dp[x][st] + val[y] < dp[y][nst]) {
dp[y][nst] = dp[x][st] + val[y];
pre[y][nst] = st << 10 | x;
if (st == nst && !in[y][nst]) {
in[y][nst] = 1;
q.push(nst << 10 | y);
}
}
}
}
}
void getans(int cnt, int mask) {
vis[cnt] = 1;
int tmp = pre[cnt][mask];
if (!tmp) return;
int x = tmp & 1023, st = tmp >> 10;
getans(x, st);
if (x == cnt) getans(x, (mask - st) | bit[cnt]);
}
int main() {
init();
int nn = (1 << k) - 1;
for (int i = 1; i <= nn; i++) {
for (int j = 0; j < n * m; j++) {
if (bit[j] && !(bit[j] & i)) continue;
for (int k = (i - 1) & i; k; k = (k - 1) & i) {
if (dp[j][i] > dp[j][k | bit[j]] + dp[j][i - k | bit[j]] - val[j]) {
dp[j][i] = dp[j][k | bit[j]] + dp[j][i - k | bit[j]] - val[j];
pre[j][i] = (k | bit[j]) << 10 | j;
}
}
if (dp[j][i] < inf) q.push(i << 10 | j), in[j][i] = 1;
}
spfa();
}
printf("%d\n", dp[u * m + v][nn]);
getans(u * m + v, nn);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (vis[i * m + j])
putchar('X');
else
putchar('.');
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x7f7f7f7f;
const int MaxK = 7;
const int MaxS = 1 << MaxK;
const int MaxG = 256;
struct Queue {
int d[MaxG], s, t;
bool empty() { return s == t; }
int pop() {
int x = d[t++];
if (t >= MaxG) t -= MaxG;
return x;
}
int push(int x) {
d[s++] = x;
if (s >= MaxG) s -= MaxG;
return x;
}
};
Queue Q;
int V[MaxG], mv[4];
int G[MaxS][MaxG];
int F[MaxS][MaxG];
bool inQ[MaxG];
char mp[MaxG];
void check(int x, int s, int r, int m) {
if (r < G[s][x]) {
G[s][x] = r;
F[s][x] = m;
if (!inQ[x]) inQ[Q.push(x)] = true;
}
}
void dfs(int s, int d) {
if (s == 0) return;
mp[d] = 'X';
int f = F[s][d];
if (f > 0) {
int u = s ^ f;
if (u > 0) {
dfs(f, d);
dfs(s ^ f, d);
}
} else {
dfs(s, d - mv[-f]);
}
}
int main() {
for (int N, M, K; scanf("%d%d%d", &N, &M, &K) != EOF && N;) {
int NM = N * M;
for (int i = 0, k = 0; i < N; i++)
for (int j = 0; j < M; j++, k++) scanf("%d", &V[k]);
int g = 1 << K;
for (int s = 0; s < g; s++) memset(G[s], 0x7f, sizeof(G[s][0]) * NM);
for (int i = 0; i < K; i++) {
int x, y;
scanf("%d%d", &x, &y);
int k = x * M + y - M - 1;
G[1 << i][k] = 0;
F[1 << i][k] = 1 << i;
}
mv[0] = -M, mv[1] = M;
mv[2] = -1, mv[3] = 1;
for (int s = 1; s < g; s++) {
for (int i = 0; i < NM; i++) {
int &cr = G[s][i];
int u = (s - 1) & s;
while (u) {
int cd = G[u][i] + G[s ^ u][i];
if (cd < cr) {
cr = cd;
F[s][i] = u;
}
u = (u - 1) & s;
}
if (cr < oo) inQ[Q.push(i)] = true;
}
while (!Q.empty()) {
int x = Q.pop();
int cd = G[s][x] + V[x];
inQ[x] = false;
if (x >= M) check(x - M, s, cd, -0);
if (x + M < NM) check(x + M, s, cd, -1);
if (x % M != 0) check(x - 1, s, cd, -2);
if ((x + 1) % M != 0) check(x + 1, s, cd, -3);
}
}
int Res = oo, ri = -1;
for (int i = 0; i < NM; i++) {
int cd = G[g - 1][i] + V[i];
if (cd < Res) Res = cd, ri = i;
}
printf("%d\n", Res);
memset(mp, '.', sizeof(mp[0]) * NM);
dfs(g - 1, ri);
for (int i = 0; i < NM; i += M) {
char c = mp[i + M];
mp[i + M] = '\0';
puts(mp + i);
mp[i + M] = c;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, cnt = 0;
queue<int> q;
int st[205], val[205];
int dp[205][128];
struct node {
int k, a, b;
} trans[205][128];
bool vis[105][105];
void getans(int a, int b) {
if (a == 0 || b == 0) {
return;
}
int x = a / m, y = a % m;
x++;
if (y == 0) {
y = m;
x--;
}
vis[x][y] = 1;
if (trans[a][b].k == 2) {
getans(trans[a][b].a, trans[a][b].b);
}
if (trans[a][b].k == 1) {
getans(a, trans[a][b].a);
getans(a, trans[a][b].b);
}
}
inline void spfa() {
while (!q.empty()) {
int t = q.front() / 1000, sta = q.front() % 1000;
q.pop();
if (t - m > 0) {
if (dp[t - m][(sta | st[t - m])] > dp[t][sta] + val[t - m]) {
dp[t - m][(sta | st[t - m])] = dp[t][sta] + val[t - m];
trans[t - m][(sta | st[t - m])].k = 2;
trans[t - m][(sta | st[t - m])].a = t;
trans[t - m][(sta | st[t - m])].b = sta;
int id = (t - m) * 1000 + (sta | st[t - m]);
q.push(id);
}
}
if (t + m <= n * m) {
if (dp[t + m][(sta | st[t + m])] > dp[t][sta] + val[t + m]) {
dp[t + m][(sta | st[t + m])] = dp[t][sta] + val[t + m];
trans[t + m][(sta | st[t + m])].k = 2;
trans[t + m][(sta | st[t + m])].a = t;
trans[t + m][(sta | st[t + m])].b = sta;
int id = (t + m) * 1000 + (sta | st[t + m]);
q.push(id);
}
}
if (t % m != 1) {
if (dp[t - 1][(sta | st[t - 1])] > dp[t][sta] + val[t - 1]) {
dp[t - 1][(sta | st[t - 1])] = dp[t][sta] + val[t - 1];
trans[t - 1][(sta | st[t - 1])].k = 2;
trans[t - 1][(sta | st[t - 1])].a = t;
trans[t - 1][(sta | st[t - 1])].b = sta;
int id = (t - 1) * 1000 + (sta | st[t - 1]);
q.push(id);
}
}
if (t % m != 0) {
if (dp[t + 1][(sta | st[t + 1])] > dp[t][sta] + val[t + 1]) {
dp[t + 1][(sta | st[t + 1])] = dp[t][sta] + val[t + 1];
trans[t + 1][(sta | st[t + 1])].k = 2;
trans[t + 1][(sta | st[t + 1])].a = t;
trans[t + 1][(sta | st[t + 1])].b = sta;
int id = (t + 1) * 1000 + (sta | st[t + 1]);
q.push(id);
}
}
}
}
int main() {
int i, j, p, x, y;
scanf("%d%d%d", &n, &m, &k);
for (i = 1; i <= n * m; i++) {
scanf("%d", &val[i]);
}
memset(dp, 0x2f, sizeof(dp));
for (i = 1; i <= k; i++) {
scanf("%d%d", &x, &y);
int id = (x - 1) * m + y;
st[id] = (1 << cnt);
dp[id][st[id]] = val[id];
cnt++;
}
int msk = (1 << cnt) - 1;
for (j = 1; j <= msk; j++) {
while (!q.empty()) {
q.pop();
}
for (i = 1; i <= n * m; i++) {
if (st[i] && (!(st[i] & j))) {
continue;
}
for (p = (j - 1) & j; p; p = (p - 1) & j) {
int s1 = p | st[i], s2 = (j - p) | st[i];
int tp = dp[i][s1] + dp[i][s2] - val[i];
if (tp < dp[i][j]) {
dp[i][j] = tp;
trans[i][j].k = 1;
trans[i][j].a = s1;
trans[i][j].b = s2;
}
}
if (dp[i][j] < 1000000000) {
q.push(i * 1000 + j);
}
}
spfa();
}
int minn = 1000000000, tra;
for (i = 1; i <= n * m; i++) {
if (dp[i][msk] < minn) {
minn = dp[i][msk];
tra = i;
}
}
printf("%d\n", minn);
getans(tra, msk);
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (vis[i][j]) {
printf("X");
} else {
printf(".");
}
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct father {
int type, num;
father(){};
father(int type, int num) : type(type), num(num){};
};
const int N = 205;
const int maxn = 130;
const int INF = 123456789;
int n, m, k;
int a[N], d[10];
int dp[maxn][N];
int ans[N], Ans;
father p[maxn][N];
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
void paint(int msk, int index) {
father cur = p[msk][index];
ans[index] = 1;
if (cur.type == -1) return;
if (!cur.type) {
paint(cur.num, index);
paint(cur.num ^ msk, index);
} else
paint(msk, cur.num);
}
void dijkstra(int msk) {
while (!pq.empty()) pq.pop();
for (int i = 0; i < n * m; i++)
if (dp[msk][i] != INF) pq.push(pair<int, int>(dp[msk][i], i));
while (!pq.empty()) {
pair<int, int> cur = pq.top();
pq.pop();
if (dp[msk][cur.second] != cur.first) continue;
father fa = father(1, cur.second);
if ((cur.second + 1) % m != 0 &&
dp[msk][cur.second + 1] > cur.first + a[cur.second + 1]) {
dp[msk][cur.second + 1] = cur.first + a[cur.second + 1];
p[msk][cur.second + 1] = fa;
pq.push(pair<int, int>(dp[msk][cur.second + 1], cur.second + 1));
}
if (cur.second % m != 0 &&
dp[msk][cur.second - 1] > cur.first + a[cur.second - 1]) {
dp[msk][cur.second - 1] = cur.first + a[cur.second - 1];
p[msk][cur.second - 1] = fa;
pq.push(pair<int, int>(dp[msk][cur.second - 1], cur.second - 1));
}
if (cur.second + m < n * m &&
dp[msk][cur.second + m] > cur.first + a[cur.second + m]) {
dp[msk][cur.second + m] = cur.first + a[cur.second + m];
p[msk][cur.second + m] = fa;
pq.push(pair<int, int>(dp[msk][cur.second + m], cur.second + m));
}
if (cur.second >= m &&
dp[msk][cur.second - m] > cur.first + a[cur.second - m]) {
dp[msk][cur.second - m] = cur.first + a[cur.second - m];
p[msk][cur.second - m] = fa;
pq.push(pair<int, int>(dp[msk][cur.second - m], cur.second - m));
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m * n; i++) scanf("%d", a + i);
for (int i = 0; i < k; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
d[i] = x * m + y;
}
for (int i = 0; i < maxn; i++)
for (int j = 0; j < N; j++) dp[i][j] = INF;
for (int i = 0; i < k; i++) {
dp[1 << i][d[i]] = a[d[i]];
p[1 << i][d[i]] = father(-1, 0);
}
for (int msk = 1; msk < (1 << k); msk++) {
for (int i = 0; i < n * m; i++)
for (int cur = msk; cur > 0; cur = (cur - 1) & msk) {
if (dp[cur][i] != INF && dp[cur ^ msk][i] != INF &&
dp[msk][i] > dp[cur][i] + dp[cur ^ msk][i] - a[i]) {
dp[msk][i] = dp[cur][i] + dp[cur ^ msk][i] - a[i];
p[msk][i] = father(0, cur);
}
}
dijkstra(msk);
}
for (int i = 1; i < n * m; i++)
if (dp[(1 << k) - 1][i] < dp[(1 << k) - 1][Ans]) Ans = i;
printf("%d\n", dp[(1 << k) - 1][Ans]);
paint((1 << k) - 1, Ans);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (ans[i * m + j])
putchar('X');
else
putchar('.');
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, a[105][105], tot;
int xi, yi, imp[10];
int dist[205][205], mdist[205][205];
int dp[1 << 7][205], parent[1 << 7][205];
bool paved[205];
void paveroad(int u, int v) {
if (dist[u][v] == 0) return;
paved[mdist[u][v]] = true;
paveroad(u, mdist[u][v]);
paveroad(mdist[u][v], v);
}
void pavegarden(int mask, int u) {
if ((mask & (mask - 1)) == 0) {
paveroad(imp[parent[mask][u]], u);
} else {
if (parent[mask][u] > tot) {
int submask = parent[mask][u] - tot;
pavegarden(submask, u);
pavegarden(mask ^ submask, u);
} else {
int v = parent[mask][u];
paved[v] = true;
paveroad(u, v);
pavegarden(mask, v);
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &a[i][j]);
int sum_important = 0;
for (int i = 0; i < k; i++) {
scanf("%d %d", &xi, &yi);
xi--, yi--;
imp[i] = xi * m + yi;
sum_important += a[xi][yi];
a[xi][yi] = 0;
}
memset(dist, 63, sizeof dist);
tot = n * m;
for (int u = 0; u < tot; u++)
for (int v = 0; v < tot; v++)
if (abs(u % m - v % m) + abs(u / m - v / m) <= 1) dist[u][v] = 0;
for (int i = 0; i < tot; i++)
for (int u = 0; u < tot; u++)
for (int v = 0; v < tot; v++) {
int ndist = dist[u][i] + a[i / m][i % m] + dist[i][v];
if (ndist < dist[u][v]) {
dist[u][v] = ndist;
mdist[u][v] = i;
}
}
memset(dp, 63, sizeof dp);
for (int mask = 1; mask < (1 << k); mask++) {
if ((mask & (mask - 1)) == 0) {
int i = 0;
while (i < k && ((mask & (1 << i)) == 0)) i++;
for (int u = 0; u < tot; u++) {
dp[mask][u] = dist[u][imp[i]];
parent[mask][u] = i;
}
} else {
for (int submask = mask - 1; submask > 0; submask = (submask - 1) & mask)
for (int u = 0; u < tot; u++) {
if (dp[mask][u] > dp[submask][u] + dp[mask ^ submask][u]) {
dp[mask][u] = dp[submask][u] + dp[mask ^ submask][u];
parent[mask][u] = tot + submask;
}
}
for (int u = 0; u < tot; u++)
for (int v = 0; v < tot; v++) {
if (dp[mask][u] > dp[mask][v] + a[v / m][v % m] + dist[u][v]) {
dp[mask][u] = dp[mask][v] + a[v / m][v % m] + dist[u][v];
parent[mask][u] = v;
}
}
}
}
int best = 1 << 30, bestu;
for (int u = 0; u < tot; u++) {
if (best > dp[(1 << k) - 1][u] + a[u / m][u % m]) {
best = dp[(1 << k) - 1][u] + a[u / m][u % m];
bestu = u;
}
}
pavegarden((1 << k) - 1, bestu);
paved[bestu] = true;
for (int i = 0; i < k; i++) paved[imp[i]] = true;
printf("%d\n", best + sum_important);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (paved[i * m + j])
printf("X");
else
printf(".");
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int c[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
int a[110][100], id[110][110], to[210][2], f[210][130], pre[210][130][4];
char b[110][110];
inline bool update(int x1, int y1, int x2, int y2, int value) {
int y = y1 | y2;
if (f[x1][y1] + f[x2][y2] + value < f[x2][y]) {
f[x2][y] = f[x1][y1] + f[x2][y2] + value;
pre[x2][y][0] = x1;
pre[x2][y][1] = y1;
pre[x2][y][2] = x2;
pre[x2][y][3] = y2;
return (true);
}
return (false);
}
void print(int x, int y) {
if (x == 0) return;
b[to[x][0]][to[x][1]] = 'X';
print(pre[x][y][0], pre[x][y][1]);
print(pre[x][y][2], pre[x][y][3]);
}
queue<int> Q;
bool in[210];
void spfa(int P, int n, int m) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) Q.push(id[i][j]);
while (!Q.empty()) {
int x0 = to[Q.front()][0], y0 = to[Q.front()][1];
in[Q.front()] = false;
Q.pop();
for (int i = 0; i < 4; i++) {
int x = x0 + c[i][0], y = y0 + c[i][1];
if (x == 0 || x > n || y == 0 || y > m) continue;
if (update(id[x0][y0], P, id[x][y], 0, a[x][y]) && !in[id[x][y]]) {
in[id[x][y]] = true;
Q.push(id[x][y]);
}
}
}
}
int main() {
int n, m, K;
scanf("%d%d%d", &n, &m, &K);
int t = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
t++;
id[i][j] = t;
to[t][0] = i, to[t][1] = j;
b[i][j] = '.';
}
memset(f, 63, sizeof(f));
int inf = f[0][0];
for (int i = 1; i <= t; i++) f[i][0] = 0;
for (int i = 0; i < K; i++) {
int x, y;
scanf("%d%d", &x, &y);
f[id[x][y]][1 << i] = a[x][y];
}
for (int i = 1; i < 1 << K; i++) {
spfa(i, n, m);
for (int j = 1; j <= n; j++)
for (int k = 1; k <= m; k++) {
if (f[id[j][k]][i] == inf) continue;
for (int l = 1; l < 1 << K; l++) {
if (i & l) continue;
if (j < n) update(id[j][k], i, id[j + 1][k], l, 0);
if (k < m) update(id[j][k], i, id[j][k + 1], l, 0);
if (j > 1) update(id[j][k], i, id[j - 1][k], l, 0);
if (k > 1) update(id[j][k], i, id[j][k - 1], l, 0);
}
}
}
int ans = inf, k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (f[id[i][j]][(1 << K) - 1] < ans) {
ans = f[id[i][j]][(1 << K) - 1];
k = id[i][j];
}
printf("%d\n", ans);
print(k, (1 << K) - 1);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) printf("%c", b[i][j]);
printf("\n");
}
return (0);
}
|
#include <bits/stdc++.h>
int n, m, k, p, a[7], c[205][205], z[205][205], d[128][205], h[128][205],
f[128][205], A = 1 << 29, R;
char o[205];
void fp(int i, int j) {
int t = z[i][j];
if (t < 0) return;
o[t] = 'X';
fp(i, t);
fp(t, j);
}
void trace(int i, int j) {
o[j] = 'X';
if (h[i][j] >= 0) {
trace(h[i][j], j);
trace(i ^ h[i][j], j);
}
if (f[i][j] >= 0 && f[i][j] != j) {
fp(j, f[i][j]);
trace(i, f[i][j]);
}
return;
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = (0); i < (n * m); i++)
for (int j = (0); j < (n * m); j++) c[i][j] = 1 << 29, z[i][j] = -1;
for (int i = (0); i < (1 << k); i++)
for (int j = (0); j < (n * m); j++)
d[i][j] = 1 << 29, h[i][j] = f[i][j] = -1;
for (int i = (0); i < (n * m); i++) o[i] = '.';
for (int i = (0); i < (n); i++)
for (int j = (0); j < (m); j++) {
scanf("%d", &c[p][p]);
p++;
}
p = 0;
for (int i = (0); i < (n); i++)
for (int j = (0); j < (m); j++) {
if (j < m - 1) c[p][p + 1] = c[p + 1][p] = c[p][p] + c[p + 1][p + 1];
if (i < n - 1) c[p][p + m] = c[p + m][p] = c[p][p] + c[p + m][p + m];
p++;
}
for (int t = (0); t < (p); t++)
for (int i = (0); i < (p); i++)
for (int j = (i + 1); j < (p); j++)
if (c[i][j] > c[i][t] + c[t][j] - c[t][t])
c[i][j] = c[j][i] = c[i][t] + c[t][j] - c[t][t],
z[i][j] = z[j][i] = t;
for (int i = (0); i < (k); i++) {
int x, y;
scanf("%d %d", &x, &y);
a[i] = (x - 1) * m + y - 1;
for (int j = (0); j < (p); j++)
d[1 << i][j] = c[a[i]][j], f[1 << i][j] = a[i];
}
for (int i = (3); i < (1 << k); i++) {
if ((i & -i) == i) continue;
for (int j = (0); j < (p); j++)
for (int t = i - 1 & i; t; t = t - 1 & i)
if (d[i][j] > d[t][j] + d[t ^ i][j] - c[j][j])
d[i][j] = d[t][j] + d[t ^ i][j] - c[j][j], h[i][j] = t;
for (int j = (0); j < (p); j++)
for (int t = (0); t < (p); t++)
if (d[i][j] > d[i][t] + c[t][j] - c[t][t])
d[i][j] = d[i][t] + c[t][j] - c[t][t], f[i][j] = t, h[i][j] = -1;
}
printf("%d\n", d[(1 << k) - 1][a[0]]);
trace((1 << k) - 1, a[0]);
for (int i = (0); i < (p); i++) {
putchar(o[i]);
if (i % m == m - 1) putchar('\n');
}
scanf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, best = INT_MAX, now, x[7], y[7], a[100][100], f[1 << 7][100][100],
path[1 << 7][100][100][3];
int dx[4] = {0, 1, 0, -1};
int dy[4] = {-1, 0, 1, 0};
inline void update(int mask) {
queue<pair<int, int> > q;
bool mark[n][m];
memset(mark, false, sizeof(mark));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (f[mask][i][j] < 1000000000) {
q.push(make_pair(i, j));
mark[i][j] = true;
}
for (; !q.empty(); q.pop()) {
pair<int, int> head = q.front();
for (int i = 0; i < 4; i++) {
pair<int, int> next;
next.first = head.first + dx[i], next.second = head.second + dy[i];
if (next.first >= 0 && next.first < n && next.second >= 0 &&
next.second < m) {
int tmp = f[mask][head.first][head.second] + a[next.first][next.second];
if (tmp < f[mask][next.first][next.second]) {
f[mask][next.first][next.second] = tmp;
path[mask][next.first][next.second][0] = 0;
path[mask][next.first][next.second][1] = head.first;
path[mask][next.first][next.second][2] = head.second;
if (!mark[next.first][next.second]) {
q.push(next);
mark[next.first][next.second] = true;
}
}
}
}
mark[head.first][head.second] = false;
}
}
void modify(int x, int y, int mask) {
a[x][y] = 0;
if (path[mask][x][y][0] == 0)
modify(path[mask][x][y][1], path[mask][x][y][2], mask);
if (path[mask][x][y][0] == 1)
modify(x, y, path[mask][x][y][1]), modify(x, y, path[mask][x][y][2]);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
for (int mask = 0; mask < 1 << k; mask++) f[mask][i][j] = 1000000000;
}
for (int i = 0; i < k; i++) {
scanf("%d%d", &x[i], &y[i]);
x[i]--;
y[i]--;
f[1 << i][x[i]][y[i]] = a[x[i]][y[i]];
path[1 << i][x[i]][y[i]][0] = 2;
}
for (int mask = 1; mask < 1 << k; mask++) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int submask = mask; submask > 0; submask = mask & (submask - 1)) {
int tmp = f[submask][i][j] + f[mask ^ submask][i][j] - a[i][j];
if (tmp < f[mask][i][j]) {
f[mask][i][j] = tmp;
path[mask][i][j][0] = 1;
path[mask][i][j][1] = submask;
path[mask][i][j][2] = mask ^ submask;
}
}
update(mask);
}
int sx, sy;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (f[(1 << k) - 1][i][j] < best) {
best = f[(1 << k) - 1][i][j];
sx = i, sy = j;
}
modify(sx, sy, (1 << k) - 1);
printf("%d\n", best);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (a[i][j] > 0)
printf(".");
else
printf("X");
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 220;
const int INF = 1000000000;
int n, m, k;
int cnt;
int val[MAXN][MAXN], id[MAXN][MAXN];
int pos[MAXN * MAXN][2];
int f[1 << 7][MAXN], path[1 << 7][MAXN][2];
bool inQ[1 << 7][MAXN];
queue<int> Q;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
void Update(int i, int j, int val, int pa, int pb) {
if (f[i][j] <= val) return;
f[i][j] = val;
path[i][j][0] = pa, path[i][j][1] = pb;
if (!inQ[i][j]) {
inQ[i][j] = 1;
Q.push(i);
Q.push(j);
}
}
bool in(int x, int y) {
if (x >= 1 && x <= n && y >= 1 && y <= m) return 1;
return 0;
}
char mp[MAXN][MAXN];
bool mark[1 << 7][MAXN];
void DFS(int a, int b) {
if (mark[a][b]) return;
mark[a][b] = 1;
int x = pos[b][0], y = pos[b][1];
mp[x][y] = 'X';
int pa = path[a][b][0], pb = path[a][b][1];
if (pb < 0) return;
if (pb == b) {
DFS(pa, pb);
DFS(a - pa, pb);
} else
DFS(pa, pb);
}
int main() {
while (~scanf("%d%d%d", &n, &m, &k)) {
cnt = 0;
memset(f, 0x3f, sizeof(f));
memset(inQ, 0, sizeof(inQ));
while (!Q.empty()) Q.pop();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
scanf("%d", val[i] + j);
id[i][j] = ++cnt;
pos[cnt][0] = i;
pos[cnt][1] = j;
}
for (int i = 1; i <= k; ++i) {
int x, y;
scanf("%d%d", &x, &y);
Update(1 << (i - 1), id[x][y], val[x][y], -1, -1);
}
while (!Q.empty()) {
int a = Q.front();
Q.pop();
int b = Q.front();
Q.pop();
inQ[a][b] = 0;
for (int i = 0; i < 4; ++i) {
int nx = pos[b][0] + dx[i], ny = pos[b][1] + dy[i];
if (!in(nx, ny)) continue;
Update(a, id[nx][ny], f[a][b] + val[nx][ny], a, b);
}
int tot = (1 << k) - 1 - a;
for (int i = tot; i; i = (i - 1) & tot)
Update(a | i, b, f[a][b] + f[i][b] - val[pos[b][0]][pos[b][1]], a, b);
}
int minx = INF;
int minj;
for (int j = 1; j <= cnt; ++j) {
if (f[(1 << k) - 1][j] < minx) {
minx = f[(1 << k) - 1][j];
minj = j;
}
}
printf("%d\n", minx);
memset(mark, 0, sizeof(mark));
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) mp[i][j] = '.';
DFS((1 << k) - 1, minj);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) printf("%c", mp[i][j]);
puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int g[100][100], h[100][100];
int imp[7][2];
int d[200][200];
int f[1 << 7][200], p[1 << 7][200][4];
void update(int con, int v, int x, int con2, int v2, int con3 = -1,
int v3 = -1) {
if (x < f[con][v]) {
f[con][v] = x;
p[con][v][0] = con2;
p[con][v][1] = v2;
p[con][v][2] = con3;
p[con][v][3] = v3;
}
}
int r[100][100];
void getpath(int i, int j) {
int yi = i / m, xi = i % m, yj = j / m, xj = j % m;
int dist = abs(yi - yj) + abs(xi - xj);
if (dist <= 1) {
r[yi][xi] = 1;
r[yj][xj] = 1;
} else {
for (int v = 0; v < n * m; v++)
if (v != i && v != j) {
int yv = v / m, xv = v % m;
if (d[i][v] + d[v][j] - g[yv][xv] == d[i][j]) {
getpath(i, v);
getpath(v, j);
break;
}
}
}
}
void reconstruct(int con, int v) {
int nodes = 0, ni = -1;
for (int i = 0; i < k; i++)
if (con & (1 << i)) {
nodes++;
ni = i;
}
if (nodes == 1) {
int y = imp[ni][0], x = imp[ni][1];
int id = y * m + x;
getpath(v, id);
} else {
int con1 = p[con][v][0], v1 = p[con][v][1];
int con2 = p[con][v][2], v2 = p[con][v][3];
if (con2 != -1) {
reconstruct(con1, v1);
reconstruct(con2, v2);
} else {
getpath(v, v1);
reconstruct(con1, v1);
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &g[i][j]);
for (int i = 0; i < k; i++) {
scanf("%d %d", &imp[i][0], &imp[i][1]);
imp[i][0]--;
imp[i][1]--;
h[imp[i][0]][imp[i][1]] = i + 1;
}
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++) {
int yi = i / m, xi = i % m, yj = j / m, xj = j % m;
d[i][j] = 999999999;
int dist = abs(yi - yj) + abs(xi - xj);
if (dist == 0) d[i][j] = g[yi][xi];
if (dist == 1) d[i][j] = g[yi][xi] + g[yj][xj];
}
for (int a = 0; a < n * m; a++) {
int r = a / m, c = a % m;
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++) {
d[i][j] = min(d[i][j], d[i][a] + d[a][j] - g[r][c]);
;
}
}
for (int con = 1; con < (1 << k); con++) {
int nodes = 0, ni = -1;
for (int i = 0; i < k; i++)
if (con & (1 << i)) {
nodes++;
ni = i;
}
for (int v = 0; v < n * m; v++) {
int &ff = f[con][v];
ff = 999999999;
if (nodes == 1) {
int y = imp[ni][0], x = imp[ni][1];
int id = y * m + x;
ff = d[v][id];
}
}
for (int v = 0; v < n * m; v++) {
int vi = v / m, vj = v % m;
int &ff = f[con][v];
for (int sub = (con - 1) & con; sub > 0; sub = (sub - 1) & con) {
update(con, v, f[sub][v] + f[con ^ sub][v] - g[vi][vj], sub, v,
con ^ sub, v);
}
}
for (int v = 0; v < n * m; v++) {
int &ff = f[con][v];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int u = i * m + j;
int val = f[con][u] + d[v][u] - g[i][j];
update(con, v, val, con, u);
}
}
}
int y0 = imp[0][0], x0 = imp[0][1];
int id0 = y0 * m + x0;
printf("%d\n", f[(1 << k) - 1][id0]);
reconstruct((1 << k) - 1, id0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (r[i][j] == 1)
printf("X");
else
printf(".");
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char CRTBUFF[30000];
struct debugger {
static void call(const char* it) {}
template <typename T, typename... aT>
static void call(const char* it, T a, aT... rest) {
string b;
for (; *it && *it != ','; ++it)
if (*it != ' ') b += *it;
cout << b << "=" << a << " ";
call(++it, rest...);
}
};
const int dx[] = {0, 0, +1, -1};
const int dy[] = {-1, +1, 0, 0};
int n, m, k, nn;
int A[220][220], imp[220], vis[220][220];
int dp[200][1000 + 10];
pair<pair<int, int>, pair<int, int> > node[200][1000 + 10];
vector<pair<int, int> > G[1000 + 10];
bool isValid(int x, int y) { return (0 <= x && x < n) && (0 <= y && y < m); }
int in(int x) { return 2 * x; }
int out(int x) { return 2 * x + 1; }
void spfa(int mask) {
queue<int> que;
for (int u = (0); u < (nn); u += (1)) que.push(u);
while (!que.empty()) {
int u = que.front();
que.pop();
for (auto it : G[u]) {
int v = it.first, w = it.second;
if (dp[mask][u] + w < dp[mask][v]) {
dp[mask][v] = dp[mask][u] + w;
node[mask][v] = {{mask, u}, {-1, -1}};
que.push(v);
}
}
}
}
void dfs(int mask, int u) {
if (mask == -1 || u == -1) return;
int x = (u / 2) / m, y = (u / 2) % m;
vis[x][y] = true;
dfs(node[mask][u].first.first, node[mask][u].first.second);
dfs(node[mask][u].second.first, node[mask][u].second.second);
}
int main() {
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
};
while (cin >> n >> m >> k) {
memset(G, 0, sizeof(G));
memset(vis, 0, sizeof(vis));
for (int i = (0); i < (n); i += (1))
for (int j = (0); j < (m); j += (1)) cin >> A[i][j];
for (int i = (0); i < (k); i += (1)) {
int x, y;
cin >> x >> y;
x--, y--;
imp[i] = out(x * m + y);
}
for (int x = (0); x < (n); x += (1))
for (int y = (0); y < (m); y += (1)) {
int u = x * m + y;
G[out(u)].push_back({in(u), A[x][y]});
for (int i = (0); i < (4); i += (1)) {
int nx = x + dx[i], ny = y + dy[i];
if (isValid(nx, ny)) {
int v = nx * m + ny;
G[in(v)].push_back({out(u), 0});
}
}
}
nn = 2 * n * m;
int lim = 1 << k;
for (int mask = (0); mask < (lim); mask += (1))
for (int u = (0); u < (nn); u += (1))
dp[mask][u] = 1000000000, node[mask][u] = {{-1, -1}, {-1, -1}};
for (int i = (0); i < (k); i += (1)) dp[1 << i][imp[i]] = 0;
for (int mask = (0); mask < (lim); mask += (1)) {
for (int u = (0); u < (nn); u += (1)) {
for (int sm = mask; sm > 0; sm = (sm - 1) & mask) {
if (dp[sm][u] + dp[sm ^ mask][u] < dp[mask][u]) {
dp[mask][u] = dp[sm][u] + dp[sm ^ mask][u];
node[mask][u] = {{sm, u}, {sm ^ mask, u}};
}
}
}
spfa(mask);
}
int ans = 1000000000;
for (int x = (0); x < (n); x += (1))
for (int y = (0); y < (m); y += (1))
ans = min(ans, dp[lim - 1][in(x * m + y)]);
for (int x = (0); x < (n); x += (1))
for (int y = (0); y < (m); y += (1)) {
if (dp[lim - 1][in(x * m + y)] == ans) {
dfs(lim - 1, in(x * m + y));
goto out;
}
}
out:
cout << ans << "\n";
for (int x = (0); x < (n); x += (1)) {
for (int y = (0); y < (m); y += (1))
if (vis[x][y])
cout << 'X';
else
cout << '.';
cout << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
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 << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
int n, m, k, a[205][205], v[205 * 205], head[205 * 205], nxt[205 * 205], cnt,
f[205][1 << 8], pre[205][1 << 8], ans[205], p[205], tot, vis[205][1 << 8];
void add(int a, int b) {
v[++cnt] = b;
nxt[cnt] = head[a];
head[a] = cnt;
}
pair<int, int> Get(int x) {
if (x % m == 0) return make_pair(x / m, m);
return make_pair((x - x % m) / m + 1, x % m);
}
void dij(int S) {
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q;
for (int i = 1; i <= tot; i++) q.push(make_pair(f[p[i]][S], p[i]));
while (!q.empty()) {
int c = q.top().second;
q.pop();
for (int i = head[c]; i; i = nxt[i]) {
pair<int, int> ID = Get(v[i]);
if (f[v[i]][S] > f[c][S] + a[ID.first][ID.second]) {
f[v[i]][S] = f[c][S] + a[ID.first][ID.second];
pre[v[i]][S] = c;
q.push(make_pair(f[v[i]][S], v[i]));
}
}
}
}
void dfs(int x, int S) {
if (vis[x][S]) return;
pair<int, int> ID = Get(x);
vis[x][S] = 1;
ans[x] = 1;
if (pre[x][S] && f[pre[x][S]][S] + a[ID.first][ID.second] == f[x][S]) {
int now = pre[x][S];
while (now) {
dfs(now, S);
now = pre[now][S];
}
}
for (int S0 = 0; S0 <= S; S0++) {
if ((S0 | S) != S) continue;
if (f[x][S0] + f[x][S - S0] - a[ID.first][ID.second] != f[x][S]) continue;
dfs(x, S0);
dfs(x, S - S0);
break;
}
}
int main() {
memset(f, 0x3f, sizeof(f));
n = read();
m = read();
k = read();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
a[i][j] = read();
if (i > 1) add(((i - 1) * m + j), ((i - 1 - 1) * m + j));
if (i < n) add(((i - 1) * m + j), ((i + 1 - 1) * m + j));
if (j > 1) add(((i - 1) * m + j), ((i - 1) * m + j - 1));
if (j < m) add(((i - 1) * m + j), ((i - 1) * m + j + 1));
}
}
int rt = 0;
for (int i = 1; i <= k; i++) {
int x = read(), y = read();
if (!rt) rt = ((x - 1) * m + y);
f[((x - 1) * m + y)][1 << (i - 1)] = a[x][y];
}
for (int S = 1; S < (1 << k); S++) {
tot = 0;
for (int i = 1; i <= n * m; i++) {
for (int S0 = 0; S0 < S; S0++) {
if ((S0 | S) != S) continue;
pair<int, int> ID = Get(i);
f[i][S] =
min(f[i][S], f[i][S0] + f[i][S - S0] - a[ID.first][ID.second]);
}
if (f[i][S] != 0x3f3f3f3f) p[++tot] = i;
}
dij(S);
}
printf("%d\n", f[rt][(1 << k) - 1]);
dfs(rt, (1 << k) - 1);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (ans[((i - 1) * m + j)])
putchar('X');
else
putchar('.');
}
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, col, row, t, x, y, ret, root;
int u[10], d[205][205], df[205][205], used[205];
int dp[205][1000], pf[205][1000], bf[205][1000];
void mkpath(int x, int y) {
if (df[x][y] == -1) {
used[x] = used[y] = 1;
return;
}
mkpath(x, df[x][y]);
mkpath(df[x][y], y);
}
void trace(int x, int y) {
if ((y & -y) == y || pf[x][y] != -1) {
if (pf[x][y] != -1)
mkpath(x, pf[x][y]), trace(pf[x][y], y);
else {
int t = -1;
for (int i = 0; t == -1; i++)
if ((1 << i) == y) t = i;
mkpath(x, u[t]);
return;
}
} else {
trace(x, bf[x][y]);
trace(x, y - bf[x][y]);
}
}
int main() {
scanf("%d%d%d", &row, &col, &m);
n = row * col;
memset(d, 63, sizeof(d));
t = 0;
for (int i = 0; i < row; i++)
for (int j = 0; j < col; j++) scanf("%d", &d[t][t]), t++;
memset(df, -1, sizeof(df));
for (int i = 0; i < row; i++)
for (int j = 0; j < col; j++) {
t = i * col + j;
if (j > 0) d[t][t - 1] = d[t][t] + d[t - 1][t - 1];
if (j < col - 1) d[t][t + 1] = d[t][t] + d[t + 1][t + 1];
if (i > 0) d[t][t - col] = d[t][t] + d[t - col][t - col];
if (i < row - 1) d[t][t + col] = d[t][t] + d[t + col][t + col];
}
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
x--, y--;
u[i] = x * col + y;
}
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
t = d[i][k] + d[k][j] - d[k][k];
if (t < d[i][j]) {
d[i][j] = t;
df[i][j] = k;
}
}
memset(pf, -1, sizeof(pf));
memset(bf, -1, sizeof(bf));
for (int i = 0; i < n; i++) {
dp[i][0] = 0;
for (int j = 0; j < m; j++) dp[i][1 << j] = d[i][u[j]];
}
for (int i = 1; i < (1 << m); i++) {
if ((i & -i) == i) continue;
for (int j = 0; j < n; j++) {
dp[j][i] = (1 << 28);
for (int k = (i - 1) & i; k > 0; k = (k - 1) & i)
if ((i | k) == i) {
t = dp[j][k] + dp[j][i - k] - d[j][j];
if (t < dp[j][i]) {
dp[j][i] = t;
bf[j][i] = i - k;
}
}
}
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++) {
t = dp[k][i] + d[j][k] - d[k][k];
if (t < dp[j][i]) {
dp[j][i] = t;
pf[j][i] = k;
}
}
}
ret = (1 << 30);
for (int i = 0; i < n; i++) {
if (dp[i][(1 << m) - 1] < ret) {
ret = dp[i][(1 << m) - 1];
root = i;
}
}
printf("%d\n", ret);
trace(root, (1 << m) - 1);
t = 0;
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) printf("%c", used[t] ? 'X' : '.'), t++;
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ans = 2e9, cnt, n, m, k, X, Y, a[110][110], Ans[110][110],
dis[110][110][130], path[110][110][130][3];
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
bool vis[110][110][130];
struct point {
int x, y, mask;
bool operator<(const point &tmp) const { return mask < tmp.mask; }
};
queue<point> q;
void draw(int x, int y, int mask) {
Ans[x][y] = 1;
if (path[x][y][mask][0] == 1) {
draw(path[x][y][mask][1], path[x][y][mask][2], mask);
}
if (path[x][y][mask][0] == 2) {
draw(x, y, path[x][y][mask][1]);
draw(x, y, path[x][y][mask][2]);
}
}
void SPFA() {
while (!q.empty()) {
point u = q.front();
q.pop();
vis[u.x][u.y][u.mask] = 0;
for (int i = 0; i < 4; i++) {
point v = (point){u.x + dx[i], u.y + dy[i], u.mask};
if (v.x < 1 || v.x > n || v.y < 1 || v.y > m) continue;
if (dis[v.x][v.y][v.mask] > dis[u.x][u.y][u.mask] + a[v.x][v.y]) {
dis[v.x][v.y][v.mask] = dis[u.x][u.y][u.mask] + a[v.x][v.y];
path[v.x][v.y][v.mask][0] = 1;
path[v.x][v.y][v.mask][1] = u.x;
path[v.x][v.y][v.mask][2] = u.y;
if (!vis[v.x][v.y][v.mask]) {
vis[v.x][v.y][v.mask] = 1;
q.push(v);
}
}
}
for (int i = 0; i < (1 << k); i++) {
if (i & u.mask) continue;
point v = (point){u.x, u.y, u.mask | i};
if (dis[v.x][v.y][v.mask] >
dis[u.x][u.y][u.mask] + dis[u.x][u.y][i] - a[u.x][u.y]) {
dis[v.x][v.y][v.mask] =
dis[u.x][u.y][u.mask] + dis[u.x][u.y][i] - a[u.x][u.y];
path[v.x][v.y][v.mask][0] = 2;
path[v.x][v.y][v.mask][1] = i;
path[v.x][v.y][v.mask][2] = u.mask;
if (!vis[v.x][v.y][v.mask]) {
vis[v.x][v.y][v.mask] = 1;
q.push(v);
}
}
}
}
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
memset(vis, 0, sizeof(vis));
memset(dis, 0x7f, sizeof(dis));
for (int i = 1; i <= k; i++) {
int x, y;
cin >> x >> y;
vis[x][y][1 << (i - 1)] = 1;
q.push((point){x, y, 1 << (i - 1)});
dis[x][y][1 << (i - 1)] = a[x][y];
}
SPFA();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (dis[i][j][(1 << k) - 1] < ans) {
ans = dis[i][j][(1 << k) - 1];
X = i;
Y = j;
}
}
}
draw(X, Y, (1 << k) - 1);
cout << ans << endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
putchar(Ans[i][j] ? 'X' : '.');
}
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int BUFFER_SIZE = 1 << 18;
const int INF = 1 << 30;
const long long LINF = 1ll << 60;
char BUFFER[BUFFER_SIZE];
int gi() {
int x;
scanf("%d", &x);
return x;
}
double gd() {
double x;
scanf("%lf", &x);
return x;
}
vector<int> gvi(int n) {
vector<int> a;
while (n--) a.push_back(gi());
return a;
}
string gs() {
scanf("%s", BUFFER);
return string(BUFFER);
}
istringstream buff() { return istringstream(string(BUFFER)); }
template <class A, class B>
ostream& operator<<(ostream& os, const pair<A, B>& d);
template <class T>
ostream& operator<<(ostream& os, const vector<T>& d);
template <class T>
ostream& operator<<(ostream& os, const queue<T>& d);
template <class T>
ostream& operator<<(ostream& os, const stack<T>& d);
template <class T>
ostream& operator<<(ostream& os, const set<T>& d);
template <class T>
ostream& operator<<(ostream& os, const multiset<T>& d);
;
template <class T>
ostream& operator<<(ostream& os, const unordered_set<T>& d) {
os << "[";
int f = 0;
for (auto x : d) {
if (f) os << ",";
f = 1;
os << x;
}
return os << "]";
};
template <class A, class B>
ostream& operator<<(ostream& os, const map<A, B>& d) {
os << "[";
int f = 0;
for (auto x : d) {
if (f) os << ",";
f = 1;
os << x;
}
return os << "]";
};
template <class A, class B>
ostream& operator<<(ostream& os, const multimap<A, B>& d) {
os << "[";
int f = 0;
for (auto x : d) {
if (f) os << ",";
f = 1;
os << x;
}
return os << "]";
};
template <class A, class B>
ostream& operator<<(ostream& os, const unordered_map<A, B>& d) {
os << "[";
int f = 0;
for (auto x : d) {
if (f) os << ",";
f = 1;
os << x;
}
return os << "]";
};
;
template <class A, class B>
ostream& operator<<(ostream& os, const pair<A, B>& d) {
return os << "[" << d.first << ", " << d.second << "]";
}
int A[111][111];
int X, Y;
int dp[1 << 7][111][111];
int dpp[1 << 7][111][111][3];
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
int Kx[8];
int Ky[8];
void go2(int m) {
for (int t = 0; t < X * Y; ++t) {
for (int x = 0; x < X; ++x) {
for (int y = 0; y < Y; ++y) {
for (int d = 0; d < 4; ++d) {
int xx = x + dx[d];
int yy = y + dy[d];
if (xx >= 0 && yy >= 0 && xx < X && yy < Y) {
if (dp[m][x][y] + A[xx][yy] < dp[m][xx][yy]) {
dp[m][xx][yy] = dp[m][x][y] + A[xx][yy];
dpp[m][xx][yy][0] = 0;
dpp[m][xx][yy][1] = x;
dpp[m][xx][yy][2] = y;
}
}
}
}
}
}
}
char C[111][111];
void restore(int m, int x, int y) {
C[x][y] = 'X';
while (dpp[m][x][y][0] == 0) {
int xx = dpp[m][x][y][1];
int yy = dpp[m][x][y][2];
x = xx;
y = yy;
C[x][y] = 'X';
}
if (dpp[m][x][y][0] == 1) {
restore(dpp[m][x][y][1], x, y);
restore(dpp[m][x][y][2], x, y);
}
}
int main() {
X = gi();
Y = gi();
int k = gi();
for (int i = 0; i < X; ++i) {
for (int j = 0; j < Y; ++j) {
A[i][j] = gi();
C[i][j] = '.';
}
}
for (int i = 0; i < k; ++i) {
Kx[i] = gi() - 1;
Ky[i] = gi() - 1;
}
for (int m = 0; m < 1 << k; ++m) {
for (int i = 0; i < X; ++i) {
for (int j = 0; j < Y; ++j) {
dp[m][i][j] = INF;
}
}
}
for (int i = 0; i < k; ++i) {
dp[1 << i][Kx[i]][Ky[i]] = A[Kx[i]][Ky[i]];
dpp[1 << i][Kx[i]][Ky[i]][0] = -1;
}
for (int m = 1; m < 1 << k; ++m) {
for (int m1 = (m - 1) & m; m1; m1 = (m1 - 1) & m) {
int m2 = m ^ m1;
for (int x = 0; x < X; ++x) {
for (int y = 0; y < Y; ++y) {
if (dp[m1][x][y] + dp[m2][x][y] - A[x][y] < dp[m][x][y]) {
dp[m][x][y] = dp[m1][x][y] + dp[m2][x][y] - A[x][y];
dpp[m][x][y][0] = 1;
dpp[m][x][y][1] = m1;
dpp[m][x][y][2] = m2;
}
}
}
}
go2(m);
}
int best = INF;
int m = (1 << k) - 1;
int xx = -1;
int yy = -1;
for (int x = 0; x < X; ++x) {
for (int y = 0; y < Y; ++y) {
if (dp[m][x][y] < best) {
best = dp[m][x][y];
xx = x;
yy = y;
}
}
}
printf("%d\n", best);
restore(m, xx, yy);
for (int i = 0; i < X; ++i) {
for (int j = 0; j < Y; ++j) {
printf("%c", C[i][j]);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int n, m, k, mask;
int a[N][N], dp[130][N][N];
int pre[130][N][N];
pair<int, int> p[10];
bool vis[N][N];
void print(pair<int, int> v, int s) {
int x = v.first, y = v.second;
vis[x][y] = 1;
if (pre[s][x][y] > 0) {
print(v, pre[s][x][y]);
print(v, s ^ pre[s][x][y]);
} else if (pre[s][x][y] < 0) {
int p = -pre[s][x][y];
if (p == 1) {
print(make_pair(x - 1, y), s);
} else if (p == 2) {
print(make_pair(x, y - 1), s);
} else if (p == 3) {
print(make_pair(x + 1, y), s);
} else
print(make_pair(x, y + 1), s);
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
}
}
for (int i = 0; i < 130; i++)
for (int j = 0; j < N; j++)
for (int k = 0; k < N; k++) dp[i][j][k] = 1e8;
for (int i = 1; i <= k; i++) {
scanf("%d%d", &p[i].first, &p[i].second);
dp[(1 << (i - 1))][p[i].first][p[i].second] = a[p[i].first][p[i].second];
pre[(1 << (i - 1))][p[i].first][p[i].second] = 0;
}
mask = (1 << k) - 1;
for (int s = 1; s <= mask; s++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int p = (s - 1) & s; p != 0; p = (p - 1) & s) {
if (dp[s][i][j] > dp[p][i][j] + dp[p ^ s][i][j] - a[i][j]) {
dp[s][i][j] = dp[p][i][j] + dp[p ^ s][i][j] - a[i][j];
pre[s][i][j] = p;
}
}
}
}
bool done = 0;
while (!done) {
done = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int cur;
if (dp[s][i - 1][j] + a[i][j] < dp[s][i][j]) {
dp[s][i][j] = dp[s][i - 1][j] + a[i][j];
pre[s][i][j] = -1;
done = 0;
}
if (dp[s][i][j - 1] + a[i][j] < dp[s][i][j]) {
dp[s][i][j] = dp[s][i][j - 1] + a[i][j];
pre[s][i][j] = -2;
done = 0;
}
if (dp[s][i + 1][j] + a[i][j] < dp[s][i][j]) {
dp[s][i][j] = dp[s][i + 1][j] + a[i][j];
pre[s][i][j] = -3;
done = 0;
}
if (dp[s][i][j + 1] + a[i][j] < dp[s][i][j]) {
dp[s][i][j] = dp[s][i][j + 1] + a[i][j];
pre[s][i][j] = -4;
done = 0;
}
}
}
}
}
int cur = INT_MAX;
pair<int, int> ver;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (dp[mask][i][j] < cur) {
ver = make_pair(i, j);
cur = dp[mask][i][j];
}
}
}
printf("%d\n", cur);
print(ver, mask);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
printf("%c", ".X"[vis[i][j]]);
}
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int n, m, k, mask;
int a[N][N], dp[130][N][N];
int pre[130][N][N];
pair<int, int> p[10];
bool vis[N][N];
void print(pair<int, int> v, int s) {
int x = v.first, y = v.second;
vis[x][y] = 1;
if (pre[s][x][y] > 0) {
print(v, pre[s][x][y]);
print(v, s ^ pre[s][x][y]);
} else if (pre[s][x][y] < 0) {
int p = -pre[s][x][y];
if (p == 1) {
print(make_pair(x - 1, y), s);
} else if (p == 2) {
print(make_pair(x, y - 1), s);
} else if (p == 3) {
print(make_pair(x + 1, y), s);
} else
print(make_pair(x, y + 1), s);
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
}
}
for (int i = 1; i < 130; i++)
for (int j = 0; j < N; j++)
for (int k = 0; k < N; k++) dp[i][j][k] = 1e6;
for (int i = 1; i <= k; i++) {
scanf("%d%d", &p[i].first, &p[i].second);
dp[(1 << (i - 1))][p[i].first][p[i].second] = a[p[i].first][p[i].second];
pre[(1 << (i - 1))][p[i].first][p[i].second] = 0;
}
mask = (1 << k) - 1;
for (int s = 1; s <= mask; s++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int p = (s - 1) & s; p > 0; p = (p - 1) & s) {
if (dp[s][i][j] > dp[p][i][j] + dp[p ^ s][i][j] - a[i][j]) {
dp[s][i][j] = dp[p][i][j] + dp[p ^ s][i][j] - a[i][j];
pre[s][i][j] = p;
}
}
}
}
bool done = 0;
while (!done) {
done = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int cur;
if (dp[s][i - 1][j] + a[i][j] < dp[s][i][j]) {
dp[s][i][j] = dp[s][i - 1][j] + a[i][j];
pre[s][i][j] = -1;
done = 0;
}
if (dp[s][i][j - 1] + a[i][j] < dp[s][i][j]) {
dp[s][i][j] = dp[s][i][j - 1] + a[i][j];
pre[s][i][j] = -2;
done = 0;
}
if (dp[s][i + 1][j] + a[i][j] < dp[s][i][j]) {
dp[s][i][j] = dp[s][i + 1][j] + a[i][j];
pre[s][i][j] = -3;
done = 0;
}
if (dp[s][i][j + 1] + a[i][j] < dp[s][i][j]) {
dp[s][i][j] = dp[s][i][j + 1] + a[i][j];
pre[s][i][j] = -4;
done = 0;
}
}
}
}
}
int cur = INT_MAX;
pair<int, int> ver;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (dp[mask][i][j] < cur) {
ver = make_pair(i, j);
cur = dp[mask][i][j];
}
}
}
printf("%d\n", cur);
print(ver, mask);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
printf("%c", ".X"[vis[i][j]]);
}
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 7;
const int M = 8;
const int INF = 1e9 + 7;
set<pair<int, pair<int, int>>> st;
vector<vector<vector<vector<int>>>> dis;
vector<vector<vector<vector<pair<int, int>>>>> pos;
int bad[N][N];
int a[N][N];
bool used[N][N];
int n, m, k;
int dp[1 << M][N][N];
pair<int, pair<int, int>> par[1 << M][N][N];
int dr[] = {1, -1, 0, 0};
int dc[] = {0, 0, 1, -1};
bool valid(int r, int c) { return r >= 0 && c >= 0 && r < n && c < m; }
void dijkstra(int sr, int sc) {
dis[sr][sc][sr][sc] = a[sr][sc];
st.insert({a[sr][sc], {sr, sc}});
while (!st.empty()) {
int r = st.begin()->second.first;
int c = st.begin()->second.second;
st.erase(st.begin());
for (int i = 0; i < 4; i++) {
int R = r + dr[i];
int C = c + dc[i];
if (valid(R, C)) {
if (dis[sr][sc][R][C] > dis[sr][sc][r][c] + a[R][C]) {
st.erase({dis[sr][sc][R][C], {R, C}});
dis[sr][sc][R][C] = dis[sr][sc][r][c] + a[R][C];
pos[sr][sc][R][C] = {r, c};
st.insert({dis[sr][sc][R][C], {R, C}});
}
}
}
}
}
void solve(int mask, int r, int c) {
auto all = par[mask][r][c];
if (all.first != -1) {
int R = all.second.first;
int C = all.second.second;
int submask = all.first;
while (r != -1) {
used[r][c] = 1;
auto p = pos[R][C][r][c];
r = p.first;
c = p.second;
}
solve(submask, R, C);
solve(mask ^ submask, R, C);
}
}
int main() {
cin >> n >> m >> k;
dis.resize(n);
pos.resize(n);
for (int i = 0; i < n; i++) {
dis[i].resize(m);
pos[i].resize(m);
for (int j = 0; j < m; j++) {
dis[i][j].resize(n);
pos[i][j].resize(n);
for (int k = 0; k < n; k++) {
dis[i][j][k].resize(m);
pos[i][j][k].resize(m);
for (int l = 0; l < m; l++) {
dis[i][j][k][l] = INF;
pos[i][j][k][l] = {-1, -1};
}
}
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
memset(bad, -1, sizeof bad);
for (int i = 0; i < k; i++) {
int r, c;
cin >> r >> c;
r--, c--;
bad[r][c] = i;
used[r][c] = 1;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) dijkstra(i, j);
memset(par, -1, sizeof par);
memset(dp, 23, sizeof dp);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
dp[0][i][j] = a[i][j];
if (bad[i][j] != -1) dp[1 << bad[i][j]][i][j] = a[i][j];
}
for (int mask = 1; mask < 1 << k; mask++)
for (int r = 0; r < n; r++)
for (int c = 0; c < m; c++)
for (int R = 0; R < n; R++)
for (int C = 0; C < m; C++)
for (int submask = mask; submask; submask = (submask - 1) & mask) {
if (dp[mask][r][c] > dp[submask][R][C] +
dp[mask ^ submask][R][C] +
dis[r][c][R][C] - 2 * a[R][C]) {
dp[mask][r][c] = dp[submask][R][C] + dp[mask ^ submask][R][C] +
dis[r][c][R][C] - a[R][C] - a[R][C];
par[mask][r][c] = {submask, {R, C}};
}
}
int ans = 1e9 + 7;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) ans = min(ans, dp[(1 << k) - 1][i][j]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (dp[(1 << k) - 1][i][j] == ans) {
cout << ans << "\n";
solve((1 << k) - 1, i, j);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (used[i][j])
cout << "X";
else
cout << ".";
cout << "\n";
}
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool debug = false;
int k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
int a[105][105];
char out[105][105];
int dp[105][105][1 << 7], path[105][105][1 << 7][3];
vector<pair<int, int>> vk;
void dd(int mask) {
for (int p = 0; p < m * n + 10; p++) {
for (int(i) = 0; (i) < (int)(n); (i)++)
for (int(j) = 0; (j) < (int)(m); (j)++)
for (int(q) = 0; (q) < (int)(4); (q)++) {
int x = dx[q] + i, y = dy[q] + j;
if (x >= 0 && y >= 0 && x < n && y < m) {
int tmp = dp[i][j][mask] + a[x][y];
if (tmp < dp[x][y][mask]) {
dp[x][y][mask] = tmp;
path[x][y][mask][0] = 2;
path[x][y][mask][1] = i;
path[x][y][mask][2] = j;
}
}
}
}
}
void pp(int i, int j, int mask) {
out[i][j] = 'X';
if (path[i][j][mask][0] == 1) {
pp(i, j, path[i][j][mask][1]);
pp(i, j, path[i][j][mask][2]);
} else if (path[i][j][mask][0] == 2) {
pp(path[i][j][mask][1], path[i][j][mask][2], mask);
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int(i) = 0; (i) < (int)(n); (i)++)
for (int(j) = 0; (j) < (int)(m); (j)++) scanf("%d", &a[i][j]);
for (int i = 0, x, y; i < k; i++) {
scanf("%d%d", &x, &y);
x--;
y--;
vk.push_back({x, y});
}
for (int p = 0; p < (1 << k); p++) {
for (int(i) = 0; (i) < (int)(n); (i)++)
for (int(j) = 0; (j) < (int)(m); (j)++) {
dp[i][j][p] = 1 << 30;
}
}
for (int p = 0; p < k; p++) {
dp[vk[p].first][vk[p].second][1 << p] = a[vk[p].first][vk[p].second];
}
for (int mask = 0; mask < (1 << k); mask++) {
for (int(i) = 0; (i) < (int)(n); (i)++)
for (int(j) = 0; (j) < (int)(m); (j)++) {
for (int subMask = mask; subMask; subMask = mask & (subMask - 1)) {
int tmp = dp[i][j][subMask] + dp[i][j][mask ^ subMask] - a[i][j];
if (tmp < dp[i][j][mask]) {
dp[i][j][mask] = tmp;
path[i][j][mask][0] = 1;
path[i][j][mask][1] = subMask;
path[i][j][mask][2] = mask ^ subMask;
}
}
}
dd(mask);
}
int ans = 1 << 30;
for (int(i) = 0; (i) < (int)(n); (i)++)
for (int(j) = 0; (j) < (int)(m); (j)++) {
ans = min(ans, dp[i][j][(1 << k) - 1]);
out[i][j] = '.';
}
printf("%d\n", ans);
for (int(i) = 0; (i) < (int)(n); (i)++)
for (int(j) = 0; (j) < (int)(m); (j)++)
if (ans == dp[i][j][(1 << k) - 1]) {
pp(i, j, (1 << k) - 1);
for (int(i) = 0; (i) < (int)(n); (i)++) puts(out[i]);
return 0;
}
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 S = 7;
const int N = 102;
int n, m, k, a[N][N], ex[S], ey[S], dp[N][N][(1 << S) + 10];
struct st {
st() {}
st(int _x, int _y, int _z) {
x = _x;
y = _y;
mask = _z;
}
bool operator<(const st) const { return true; }
int x, y, mask;
};
st pre[N][N][(1 << S) + 10];
bool g[N][N];
priority_queue<pair<int, st>, vector<pair<int, st> >, greater<pair<int, st> > >
pq;
int dx[] = {1, 0, 0, -1};
int dy[] = {0, 1, -1, 0};
inline bool isvalid(int x, int y) {
if (x < 0 || x >= n || y < 0 || y >= m) return false;
return true;
}
void go(int x, int y, int mask) {
if (x == -1 || !mask) return;
g[x][y] = true;
st u = pre[x][y][mask];
go(u.x, u.y, u.mask);
if (u.mask != mask && u.mask) go(x, y, u.mask ^ mask);
}
int main() {
n = getint();
m = getint();
k = getint();
for (int(i) = 0; (i) < (n); (i)++)
for (int(j) = 0; (j) < (m); (j)++) a[i][j] = getint();
for (int(i) = 0; (i) < (n); (i)++)
for (int(j) = 0; (j) < (m); (j)++)
for (int(k) = 0; (k) < (1 << S); (k)++) dp[i][j][k] = 1000000000;
for (int(i) = 0; (i) < (k); (i)++) {
ex[i] = getint() - 1, ey[i] = getint() - 1;
dp[ex[i]][ey[i]][1 << i] = a[ex[i]][ey[i]];
pre[ex[i]][ey[i]][1 << i] = st(-1, -1, 0);
pq.push(make_pair(a[ex[i]][ey[i]], st(ex[i], ey[i], 1 << i)));
}
while (!pq.empty()) {
pair<int, st> uu = pq.top();
pq.pop();
st u = uu.second;
assert(u.mask);
if (uu.first > dp[u.x][u.y][u.mask]) continue;
for (int(i) = 0; (i) < (4); (i)++) {
int fx = u.x + dx[i], fy = u.y + dy[i];
if (!isvalid(fx, fy)) continue;
if (dp[u.x][u.y][u.mask] + a[fx][fy] < dp[fx][fy][u.mask]) {
dp[fx][fy][u.mask] = dp[u.x][u.y][u.mask] + a[fx][fy];
pre[fx][fy][u.mask] = st(u.x, u.y, u.mask);
pq.push(make_pair(dp[fx][fy][u.mask], st(fx, fy, u.mask)));
}
for (int(msk) = 0; (msk) < (1 << k); (msk)++)
if (!(msk & u.mask) && msk > 0) {
if (dp[fx][fy][msk | u.mask] >
dp[u.x][u.y][u.mask] + dp[fx][fy][msk]) {
dp[fx][fy][msk | u.mask] = dp[u.x][u.y][u.mask] + dp[fx][fy][msk];
pre[fx][fy][msk | u.mask] = st(u.x, u.y, u.mask);
pq.push(
make_pair(dp[fx][fy][msk | u.mask], st(fx, fy, msk | u.mask)));
}
}
}
}
int sx = -1, sy = -1, res = 1000000000;
for (int(i) = 0; (i) < (n); (i)++)
for (int(j) = 0; (j) < (m); (j)++)
if (dp[i][j][(1 << k) - 1] < res) {
res = dp[i][j][(1 << k) - 1];
sx = i;
sy = j;
}
printf("%d\n", res);
go(sx, sy, (1 << k) - 1);
for (int(i) = 0; (i) < (n); (i)++) {
for (int(j) = 0; (j) < (m); (j)++)
if (g[i][j])
printf("X");
else
printf(".");
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e2 + 100, OO = 1e18, M = 998244353, P = 6151, SQ = 1000,
lg = 30;
long long dp[N][N], a[N], fdp[N][N], bit[(1 << 8)][N], n, m, h;
bitset<N> dis[N][N], num[N][N];
bool mark[N][N];
inline long long pos(long long i, long long j) {
if (i == 0 || j == 0 || i > n || j > m) return 0;
return ((i - 1) * m + j);
}
void dfs(long long x, long long y) {
if (mark[x][y] || fdp[x][y] == 0) return;
mark[x][y] = true;
dfs(x, fdp[x][y]), dfs(fdp[x][y], y);
dis[x][y] = dis[x][fdp[x][y]] | dis[fdp[x][y]][y];
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m >> h;
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= m; j++) cin >> a[pos(i, j)];
memset(dp, 63, sizeof(dp));
memset(bit, 63, sizeof(bit));
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
dp[pos(i, j)][pos(i, j)] = a[pos(i, j)];
dp[pos(i, j)][pos(i + 1, j)] = a[pos(i, j)] + a[pos(i + 1, j)];
dp[pos(i, j)][pos(i - 1, j)] = a[pos(i, j)] + a[pos(i - 1, j)];
dp[pos(i, j)][pos(i, j + 1)] = a[pos(i, j)] + a[pos(i, j + 1)];
dp[pos(i, j)][pos(i, j - 1)] = a[pos(i, j)] + a[pos(i, j - 1)];
bit[0][pos(i, j)] = a[pos(i, j)];
dis[pos(i, j)][pos(i, j)][pos(i, j)] = 1;
dis[pos(i, j)][pos(i + 1, j)][pos(i, j)] = 1,
dis[pos(i, j)][pos(i + 1, j)]
[pos(i + 1, j)] = 1;
dis[pos(i, j)][pos(i - 1, j)][pos(i, j)] = 1,
dis[pos(i, j)][pos(i - 1, j)]
[pos(i - 1, j)] = 1;
dis[pos(i, j)][pos(i, j + 1)][pos(i, j)] = 1,
dis[pos(i, j)][pos(i, j + 1)]
[pos(i, j + 1)] = 1;
dis[pos(i, j)][pos(i, j - 1)][pos(i, j)] = 1,
dis[pos(i, j)][pos(i, j - 1)]
[pos(i, j - 1)] = 1;
num[0][pos(i, j)][pos(i, j)] = 1;
}
}
for (long long k = 1; k <= pos(n, m); k++) {
for (long long i = 1; i <= pos(n, m); i++) {
for (long long j = 1; j <= pos(n, m); j++) {
long long t = dp[i][j];
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j] - a[k]);
if (dp[i][j] < t) fdp[i][j] = k;
}
}
}
for (long long i = 1; i <= pos(n, m); i++)
for (long long j = 1; j <= pos(n, m); j++) dfs(i, j);
vector<long long> v;
for (long long i = 0; i < h; i++) {
long long x, y;
cin >> x >> y;
v.push_back(pos(x, y));
for (long long j = 1; j <= pos(n, m); j++)
bit[(1 << i)][j] = dp[pos(x, y)][j], num[(1 << i)][j] = dis[pos(x, y)][j];
}
for (long long msk = 1; msk < (1 << h); msk++) {
if ((msk & -msk) == msk) continue;
for (long long i = 1; i <= pos(n, m); i++) {
long long sb = -1, k = -1;
for (long long sub = 0; sub < (1 << h); sub++) {
if ((msk & sub) != sub) continue;
for (long long j = 1; j <= pos(n, m); j++) {
long long t = bit[msk][i];
bit[msk][i] =
min(min(bit[msk][i],
bit[sub][j] + bit[msk ^ sub][i] + dp[i][j] - a[i] - a[j]),
bit[sub][i] + bit[msk ^ sub][j] + dp[i][j] - a[i] - a[j]);
if (bit[msk][i] != t) sb = sub, k = j;
}
}
if (sb == -1) continue;
if (bit[msk][i] == bit[sb][k] + bit[msk ^ sb][i] + dp[i][k] - a[i] - a[k])
num[msk][i] = num[sb][k] | num[msk ^ sb][i] | dis[i][k];
else
num[msk][i] = num[sb][i] | num[msk ^ sb][k] | dis[i][k];
}
}
cout << bit[(1 << h) - 1][v[0]] << endl;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
if (num[(1 << h) - 1][v[0]][pos(i, j)] == 1)
cout << 'X';
else
cout << '.';
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 99999999;
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, 1, 0, -1};
int n, m, nn;
int val[105][105];
int dp[220][1 << 7], pre[220][1 << 7];
char ans[105][105];
bool inq[220][1 << 7];
queue<int> Q;
void update(int pos, int st, int v, int fa) {
if (dp[pos][st] <= v) return;
dp[pos][st] = v;
pre[pos][st] = fa;
if (!inq[pos][st]) {
inq[pos][st] = 1;
Q.push(pos);
Q.push(st);
}
}
void dfs(int pos, int st) {
int i, x, y;
x = pos / m, y = pos % m;
ans[x][y] = 'X';
if (pre[pos][st] == -1) return;
int ppos = pre[pos][st] / 1000, pst = pre[pos][st] % 1000;
dfs(ppos, pst);
if (st - pst) dfs(ppos, st - pst);
}
int main() {
int i, j, t, k, T;
int x, y, xx, yy, st, pos, now;
while (scanf("%d %d %d", &n, &m, &nn) != EOF) {
while (!Q.empty()) Q.pop();
T = (1 << nn);
t = 0;
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j) scanf("%d", &val[i][j]);
for (i = 0; i < n * m; ++i)
for (j = 0; j < T; ++j) dp[i][j] = INF;
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) ans[i][j] = '.';
ans[i][m] = '\0';
}
memset(inq, 0, sizeof(inq));
for (i = 0; i < nn; ++i) {
scanf("%d %d", &k, &t);
k--;
t--;
update(k * m + t, (1 << i), val[k][t], -1);
}
while (!Q.empty()) {
pos = Q.front();
Q.pop();
st = Q.front();
Q.pop();
inq[pos][st] = 0;
x = pos / m;
y = pos % m;
for (i = 0; i < 4; ++i) {
xx = x + dx[i];
yy = y + dy[i];
if (xx >= 0 && xx < n && yy >= 0 && yy < m)
update(xx * m + yy, st, dp[pos][st] + val[xx][yy], pos * 1000 + st);
}
now = T - 1 - st;
for (i = now; i; i = (i - 1) & now)
update(pos, i | st, dp[pos][st] + dp[pos][i] - val[x][y],
pos * 1000 + st);
}
t = INF;
for (i = 0; i < n * m; ++i)
if (dp[i][T - 1] < t) {
t = dp[i][T - 1];
k = i;
}
dfs(k, T - 1);
printf("%d\n", t);
for (i = 0; i < n; ++i) printf("%s\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class t>
inline t read(t &x) {
x = 0;
char c = getchar();
bool f = 0;
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
if (f) x = -x;
return x;
}
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);
}
}
const int dx[4] = {-1, 1, 0, 0}, dy[4] = {0, 0, -1, 1};
const int N = 105, S = (1 << 7) + 5;
int n, m, k, a[N][N], f[N][N][S], ans = 0x3f3f3f3f;
bool bd[N][N], v[N][N][S];
struct node {
int x, y, s;
} pre[N][N][S];
queue<node> q;
void print(node s) {
if (pre[s.x][s.y][s.s].s == -1) return;
if (pre[s.x][s.y][s.s].s == 0) {
print((node){s.x, s.y, pre[s.x][s.y][s.s].x});
print((node){s.x, s.y, pre[s.x][s.y][s.s].y});
} else {
bd[s.x][s.y] = 1;
print((node){pre[s.x][s.y][s.s].x, pre[s.x][s.y][s.s].y, s.s});
}
}
signed main() {
read(n);
read(m);
read(k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) read(a[i][j]);
for (int s = 0; s < (1 << k); s++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
f[i][j][s] = 0x3f3f3f3f;
pre[i][j][s] = (node){-1, -1, -1};
}
for (int i = 0, x, y; i < k; i++) {
read(x);
read(y);
f[x][y][1 << i] = a[x][y];
bd[x][y] = 1;
q.push((node){x, y, 1 << i});
v[x][y][1 << i] = 1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (!bd[i][j]) {
f[i][j][0] = a[i][j];
q.push((node){i, j, 0});
v[i][j][0] = 1;
}
while (!q.empty()) {
node x = q.front();
q.pop();
v[x.x][x.y][x.s] = 0;
for (int s = 1; s < (1 << k); s++)
if ((s & x.s) == 0) {
if (f[x.x][x.y][s | x.s] >
f[x.x][x.y][x.s] + f[x.x][x.y][s] - a[x.x][x.y]) {
f[x.x][x.y][s | x.s] =
f[x.x][x.y][x.s] + f[x.x][x.y][s] - a[x.x][x.y];
pre[x.x][x.y][s | x.s] = (node){x.s, s, 0};
if (!v[x.x][x.y][x.s | s]) {
v[x.x][x.y][x.s | s] = 1;
q.push((node){x.x, x.y, x.s | s});
}
}
}
for (int i = 0; i < 4; i++) {
int nx = x.x + dx[i], ny = x.y + dy[i];
if (nx >= 1 && ny >= 1 && nx <= n && ny <= m) {
if (f[nx][ny][x.s] > f[x.x][x.y][x.s] + a[nx][ny]) {
f[nx][ny][x.s] = f[x.x][x.y][x.s] + a[nx][ny];
pre[nx][ny][x.s] = (node){x.x, x.y, 1};
v[nx][ny][x.s] = 1;
q.push((node){nx, ny, x.s});
}
}
}
}
node start = (node){0, 0, (1 << k) - 1};
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (f[i][j][(1 << k) - 1] < ans) {
ans = f[i][j][(1 << k) - 1];
start = (node){i, j, start.s};
}
write(ans);
print(start);
for (int i = 1; i <= n; i++) {
puts("");
for (int j = 1; j <= m; j++) putchar(bd[i][j] ? 'X' : '.');
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n, m, k;
int dp[110][110][1024], vis[110][110][1024], a[110][110], cover[110][110];
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
struct NODE {
int x, y, state;
NODE() {}
NODE(int _x, int _y, int _state) { x = _x, y = _y, state = _state; }
};
NODE pre[110][110][1024];
void Cover(int x, int y, int state) {
if (state == -1) return;
NODE temp = pre[x][y][state];
if (temp.state == 0) {
Cover(x, y, temp.x);
Cover(x, y, temp.y);
}
if (temp.state == 1) {
Cover(temp.x, temp.y, state);
cover[x][y] = 1;
}
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
}
}
queue<NODE> Q;
memset(dp, INF, sizeof(dp));
for (int i = 1; i <= k; i++) {
int x, y;
scanf("%d %d", &x, &y);
cover[x][y] = 1;
dp[x][y][1 << (i - 1)] = a[x][y];
vis[x][y][1 << (i - 1)] = 1;
Q.push(NODE(x, y, 1 << (i - 1)));
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
pre[i][j][0] = NODE(-1, -1, -1);
if (!cover[i][j]) {
dp[i][j][0] = a[i][j];
Q.push(NODE(i, j, 0));
vis[i][j][0] = 1;
}
}
}
while (!Q.empty()) {
NODE u = Q.front();
Q.pop();
vis[u.x][u.y][u.state] = 0;
for (int i = 1; i < (1 << k); i++) {
if ((i & u.state) == 0) {
if (dp[u.x][u.y][u.state ^ i] >
dp[u.x][u.y][u.state] + dp[u.x][u.y][i] - a[u.x][u.y]) {
dp[u.x][u.y][u.state ^ i] =
dp[u.x][u.y][u.state] + dp[u.x][u.y][i] - a[u.x][u.y];
pre[u.x][u.y][u.state ^ i] = NODE(u.state, i, 0);
if (!vis[u.x][u.y][u.state ^ i]) {
vis[u.x][u.y][u.state ^ i] = 1;
Q.push(NODE(u.x, u.y, u.state ^ i));
}
}
}
}
for (int i = 0; i < 4; i++) {
int xx = u.x + dx[i];
int yy = u.y + dy[i];
if (xx < 1 || xx > n || yy < 1 || yy > m) continue;
if (dp[xx][yy][u.state] > dp[u.x][u.y][u.state] + a[xx][yy]) {
dp[xx][yy][u.state] = dp[u.x][u.y][u.state] + a[xx][yy];
vis[xx][yy][u.state] = 1;
Q.push(NODE(xx, yy, u.state));
pre[xx][yy][u.state] = NODE(u.x, u.y, 1);
}
}
}
int min_x, min_y, min_w = INF;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (min_w > dp[i][j][(1 << k) - 1]) {
min_w = dp[i][j][(1 << k) - 1];
min_x = i, min_y = j;
}
}
}
Cover(min_x, min_y, (1 << k) - 1);
printf("%d\n", min_w);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (cover[i][j])
printf("X");
else
printf(".");
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int DISJOINTED = 1;
const int TRASITIVE = 2;
int r, c, k;
int bd[100][100];
int xs[7];
int ys[7];
int dp[100][100][1 << 7];
int from[100][100][1 << 7][3];
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
bool pave[100][100];
void update(int mask) {
for (int k = 0; k < (int)(r * c + 10); k++) {
for (int i = 0; i < (int)(r); i++)
for (int j = 0; j < (int)(c); j++) {
for (int d = 0; d < (int)(4); d++) {
int x = i + dx[d];
int y = j + dy[d];
if (0 <= x && x < r && 0 <= y && y < c) {
int tmp = dp[i][j][mask] + bd[x][y];
if (tmp < dp[x][y][mask]) {
dp[x][y][mask] = tmp;
from[x][y][mask][0] = TRASITIVE;
from[x][y][mask][1] = i;
from[x][y][mask][2] = j;
}
}
}
}
}
}
void fillSquare(int x, int y, int mask) {
pave[x][y] = true;
if (from[x][y][mask][0] == TRASITIVE)
fillSquare(from[x][y][mask][1], from[x][y][mask][2], mask);
else if (from[x][y][mask][0] == DISJOINTED) {
fillSquare(x, y, from[x][y][mask][1]);
fillSquare(x, y, from[x][y][mask][2]);
}
}
int main() {
cin >> r >> c >> k;
for (int i = 0; i < (int)(r); i++)
for (int j = 0; j < (int)(c); j++) scanf("%d", bd[i] + j);
for (int i = 0; i < (int)(k); i++) {
scanf("%d %d", xs + i, ys + i);
--xs[i];
--ys[i];
}
for (int i = 0; i < (int)(r); i++)
for (int j = 0; j < (int)(c); j++)
for (int mask = 0; mask < (int)(1 << k); mask++) {
dp[i][j][mask] = 999999999;
from[i][j][mask][0] = 0;
}
for (int i = 0; i < (int)(k); i++)
dp[xs[i]][ys[i]][1 << i] = bd[xs[i]][ys[i]];
for (int mask = 0; mask < (int)(1 << k); mask++) {
for (int i = 0; i < (int)(r); i++)
for (int j = 0; j < (int)(c); j++) {
for (int sub = (mask - 1) & mask; sub > 0; sub = (sub - 1) & mask) {
int tmp = dp[i][j][sub] + dp[i][j][mask ^ sub] - bd[i][j];
if (tmp < dp[i][j][mask]) {
dp[i][j][mask] = tmp;
from[i][j][mask][0] = DISJOINTED;
from[i][j][mask][1] = sub;
from[i][j][mask][2] = mask ^ sub;
}
}
}
update(mask);
}
int ret = 999999999;
int x;
int y;
for (int i = 0; i < (int)(r); i++)
for (int j = 0; j < (int)(c); j++) {
if (dp[i][j][(1 << k) - 1] < ret) {
ret = dp[i][j][(1 << k) - 1];
x = i;
y = j;
}
}
cout << ret << endl;
memset(pave, 0, sizeof(pave));
fillSquare(x, y, (1 << k) - 1);
for (int i = 0; i < (int)(r); i++)
for (int j = 0; j < (int)(c); j++) {
if (pave[i][j])
cout << 'X';
else
cout << '.';
if (j == c - 1) cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
struct AS {
int x, y, mask;
AS() {}
AS(int x, int y, int mask) : x(x), y(y), mask(mask) {}
} pre[maxn][maxn][1 << 7];
int n, m, k, full, a[maxn][maxn], dp[maxn][maxn][1 << 7];
bool vis[maxn][maxn];
inline int read() {
int res = 0, f_f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f_f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
res = (res << 3) + (res << 1) + (ch - '0'), ch = getchar();
return res * f_f;
}
inline bool chkmin(int &x, int y) {
if (y == -1) return false;
if (x == -1 || x > y) {
x = y;
return true;
}
return false;
}
inline void solve(AS x) {
if (!x.x || !x.y) return;
vis[x.x][x.y] = true;
solve(pre[x.x][x.y][x.mask]);
if (x.mask == (x.mask ^ pre[x.x][x.y][x.mask].mask)) return;
solve(AS(x.x, x.y, x.mask ^ pre[x.x][x.y][x.mask].mask));
}
int main() {
memset(dp, -1, sizeof(dp));
n = read(), m = read(), k = read(), full = (1 << k) - 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
a[i][j] = read(), dp[i][j][0] = a[i][j];
pre[i][j][0] = AS(0, 0, 0);
}
for (int i = 1; i <= k; i++) {
int x = read(), y = read();
dp[x][y][1 << i - 1] = a[x][y], dp[x][y][0] = -1;
pre[x][y][1 << i - 1] = AS(0, 0, 0);
}
for (int mask = 0; mask <= full; mask++) {
int T = n * m + 5;
while (T--) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int sta = mask; sta; sta = mask & (sta - 1)) {
int res = -1;
AS cur;
if (dp[i][j][mask ^ sta] == -1) continue;
if (i && chkmin(res, dp[i - 1][j][sta])) cur = AS(i - 1, j, sta);
if (i <= n && chkmin(res, dp[i + 1][j][sta]))
cur = AS(i + 1, j, sta);
if (j && chkmin(res, dp[i][j - 1][sta])) cur = AS(i, j - 1, sta);
if (j <= m && chkmin(res, dp[i][j + 1][sta]))
cur = AS(i, j + 1, sta);
if (res == -1) continue;
if (chkmin(dp[i][j][mask], dp[i][j][mask ^ sta] + res))
pre[i][j][mask] = cur;
}
}
}
}
}
int ans = -1;
AS cur;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (chkmin(ans, dp[i][j][full])) cur = AS(i, j, full);
solve(cur);
printf("%d\n", ans);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (vis[i][j])
printf("X");
else
printf(".");
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > L;
int N, M, K;
int T[1 << 7][205];
int tr[1 << 7][205];
int D[105][105];
char ans[105][105];
int xx[4] = {-1, 0, 1, 0};
int yy[4] = {0, 1, 0, -1};
int hsh(int x, int y) { return x * M + y; }
void trace(int ad, int x, int y) {
ans[x][y] = 'X';
if (T[ad][hsh(x, y)] == D[x][y]) return;
int d = tr[ad][hsh(x, y)];
if (d <= 0)
trace(ad, x - xx[-d], y - yy[-d]);
else
trace(d, x, y), trace(ad ^ d, x, y);
}
int main() {
scanf("%d%d%d", &N, &M, &K);
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
scanf("%d", D[i] + j);
ans[i][j] = '.';
}
}
for (int i = 0; i < K; i++) {
int A, B;
scanf("%d%d", &A, &B);
A--, B--;
L.push_back(pair<int, int>(A, B));
}
for (int i = 1; i < 1 << K; i++) {
for (int j = 0; j < N * M; j++) T[i][j] = 0x3fffffff;
}
for (int i = 0; i < K; i++) {
T[1 << i][hsh(L[i].first, L[i].second)] = D[L[i].first][L[i].second];
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
T[0][hsh(i, j)] = D[i][j];
}
}
for (int i = 1; i < 1 << K; i++) {
for (int j = i; j; j = (j - 1) & i) {
for (int k = 0; k < N; k++) {
for (int l = 0; l < M; l++) {
int tmp = T[i][hsh(k, l)];
T[i][hsh(k, l)] = min(
T[i][hsh(k, l)], T[j][hsh(k, l)] + T[i ^ j][hsh(k, l)] - D[k][l]);
if (T[i][hsh(k, l)] != tmp) tr[i][hsh(k, l)] = j;
}
}
}
bool chk[105][105] = {0};
for (int t = 0; t < N * M; t++) {
int rx = -1, ry = -1;
for (int x = 0; x < N; x++) {
for (int y = 0; y < M; y++) {
if (!chk[x][y] && (rx == -1 || T[i][hsh(rx, ry)] > T[i][hsh(x, y)]))
rx = x, ry = y;
}
}
chk[rx][ry] = true;
for (int d = 0; d < 4; d++) {
int px = rx + xx[d], py = ry + yy[d];
if (px < 0 || px >= N || py < 0 || py >= M) continue;
int tmp = T[i][hsh(px, py)];
T[i][hsh(px, py)] =
min(T[i][hsh(px, py)], T[i][hsh(rx, ry)] + D[px][py]);
if (T[i][hsh(px, py)] != tmp) tr[i][hsh(px, py)] = -d;
}
}
}
int rx = 0, ry = 0, to = (1 << K) - 1;
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if (T[to][hsh(i, j)] < T[to][hsh(rx, ry)]) rx = i, ry = j;
}
}
trace(to, rx, ry);
printf("%d\n", T[to][hsh(rx, ry)]);
for (int i = 0; i < N; i++) printf("%s\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void run();
int main() {
ios::sync_with_stdio(0);
run();
}
unsigned v[200];
unsigned n, m, k;
unsigned st[1 << 7][200];
unsigned fr[1 << 7][200];
unsigned freud[200][200];
vector<int> edges(int x) {
vector<int> res;
if (x % m) res.push_back(x - 1);
if ((x + 1) % m) res.push_back(x + 1);
if (x >= m) res.push_back(x - m);
if (x + m < n * m) res.push_back(x + m);
return res;
}
long long val = 0;
void dfs(int mask, int x) {
if (not mask) return;
if (~v[x]) val += v[x], v[x] = -1;
if (!~fr[mask][x]) return;
int tom = fr[mask][x] & 0x7F;
int top = fr[mask][x] >> 7;
if (tom != mask) {
dfs(mask ^ tom, x);
dfs(mask & tom, x);
} else {
while (x != top) {
for (int y : edges(x))
if (freud[x][y] + freud[y][top] == freud[x][top]) {
x = y;
break;
}
if (~v[x]) val += v[x], v[x] = -1;
}
dfs(tom, top);
}
}
void run() {
memset(freud, -1, sizeof freud);
memset(st, -1, sizeof st);
memset(fr, -1, sizeof fr);
cin >> n >> m >> k;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> v[i * m + j];
for (int i = 0; i < n * m; freud[i][i] = 0, ++i)
for (int j : edges(i)) freud[i][j] = v[j];
for (int i = n * m; i--;)
for (int j = n * m; j--;)
for (int k = n * m; k--;)
if (~(freud[j][i] | freud[i][k]))
freud[j][k] = min(freud[j][k], freud[j][i] + freud[i][k]);
for (int i = n * m; i--;) st[0][i] = v[i];
for (int i = 0; i < k; i++) {
int r, c;
cin >> r >> c;
--r, --c;
st[1 << i][r * m + c] = v[r * m + c];
}
for (int msk = 0, steps = pow(3, k) + 0.5; msk < steps; ++msk) {
int mask = 0, musk = 0;
for (int i = msk, j = 0; j < k; j++, i /= 3)
(mask <<= 1) |= (i % 3 == 1), (musk <<= 1) |= (i % 3 == 2);
if (not mask)
for (int i = n * m; i--;)
for (int j = n * m; j--;)
if ((~st[musk][j]) and st[musk][i] > st[musk][j] + freud[j][i])
st[musk][i] = st[musk][j] + freud[j][i],
fr[musk][i] = (j << 7) | musk;
if (not musk)
for (int i = n * m; i--;)
for (int j = n * m; j--;)
if ((~st[mask][j]) and st[mask][i] > st[mask][j] + freud[j][i])
st[mask][i] = st[mask][j] + freud[j][i],
fr[mask][i] = (j << 7) | mask;
for (int i = n * m; i--;)
if ((~st[mask][i]) and (~st[musk][i]))
if (st[mask | musk][i] > st[mask][i] + st[musk][i] - v[i])
st[mask | musk][i] = st[mask][i] + st[musk][i] - v[i],
fr[mask | musk][i] = (i << 7) | mask;
}
unsigned res = -1, rex = -1;
for (int i = n * m; i--;)
if (st[(1 << k) - 1][i] < res) res = st[(1 << k) - 1][i], rex = i;
if (!~res) res = rex = 0;
dfs((1 << k) - 1, rex);
cout << res << endl;
for (int i = 0; i < n; i++, cout << '\n')
for (int j = 0; j < m; j++) cout << (~v[i * m + j] ? '.' : 'X');
}
|
#include <bits/stdc++.h>
using namespace std;
int f[205], ans, aa[205];
int a[205], n, m, k, dis[205][205], opt[205][205], path[205][205], p[205][205];
int d[4][2] = {{1, 0}, {-1, 0}, {0, -1}, {0, 1}};
int fun(int i, int j) { return (i - 1) * m + j; }
void floyd() {
int l = n * m;
int i, j, h;
for (h = 1; h <= l; h++)
for (i = 1; i <= l; i++)
for (j = 1; j <= l; j++)
if (dis[i][j] > dis[i][h] + dis[h][j] - dis[h][h]) {
dis[i][j] = dis[i][h] + dis[h][j] - dis[h][h];
p[i][j] = p[h][j];
}
}
void dfs(int s, int i) {
if (path[s][i] == -1) return;
if (path[s][i] > n * m) {
int t = path[s][i] - n * m;
if (a[i] != -1) ans += a[i];
a[i] = -1;
dfs(t, i);
dfs(s ^ t, i);
} else {
if (a[i] != -1) ans += a[i];
a[path[s][i]] = -1;
dfs(s, path[s][i]);
int tm = path[s][i];
while (tm != i) {
tm = p[i][tm];
if (a[i] != -1) ans += a[i];
a[tm] = -1;
}
}
}
int main() {
int i, j, l, x, y, s;
while (scanf("%d%d%d", &n, &m, &k) != -1) {
memset(f, -1, sizeof(f));
memset(path, -1, sizeof path);
memset(p, -1, sizeof path);
for (i = 1; i <= n * m; i++)
for (j = 1; j <= n * m; j++) dis[i][j] = 1000000000;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
scanf("%d", &a[fun(i, j)]);
dis[fun(i, j)][fun(i, j)] = a[fun(i, j)];
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
if (i != 1)
dis[fun(i, j)][fun(i - 1, j)] = a[fun(i, j)] + a[fun(i - 1, j)],
p[fun(i, j)][fun(i - 1, j)] = fun(i, j);
if (i != n)
dis[fun(i, j)][fun(i + 1, j)] = a[fun(i, j)] + a[fun(i + 1, j)],
p[fun(i, j)][fun(i + 1, j)] = fun(i, j);
if (j != 1)
dis[fun(i, j)][fun(i, j - 1)] = a[fun(i, j)] + a[fun(i, j - 1)],
p[fun(i, j)][fun(i, j - 1)] = fun(i, j);
if (j != m)
dis[fun(i, j)][fun(i, j + 1)] = a[fun(i, j)] + a[fun(i, j + 1)],
p[fun(i, j)][fun(i, j + 1)] = fun(i, j);
}
floyd();
for (i = 1; i <= n * m; i++) {
p[i][i] = i;
opt[0][i] = a[i];
for (s = 1; s < (1 << k); s++) opt[s][i] = 1000000000;
}
for (i = 0; i < k; i++) {
scanf("%d%d", &x, &y);
f[fun(x, y)] = i;
opt[1 << i][fun(x, y)] = a[fun(x, y)];
}
for (int u = 1; u < 10; u++) {
for (s = 1; s < (1 << k); s++) {
for (i = 1; i <= n * m; i++) {
for (j = 1; j <= n * m; j++) {
if (opt[s][i] > opt[s][j] + dis[i][j] - a[j]) {
opt[s][i] = opt[s][j] + dis[i][j] - a[j];
path[s][i] = j;
}
}
for (j = 1; j < s; j++) {
if (opt[s][i] > opt[j][i] + opt[s ^ j][i] - a[i]) {
opt[s][i] = opt[j][i] + opt[s ^ j][i] - a[i];
path[s][i] = n * m + j;
}
}
}
}
}
ans = 1000000000;
for (i = 1; i <= n * m; i++) {
if (opt[(1 << k) - 1][i] < ans) {
ans = opt[(1 << k) - 1][i];
s = i;
}
}
a[s] = -1;
dfs((1 << k) - 1, s);
printf("%d\n", ans);
for (i = 1; i <= n; i++, printf("\n"))
for (j = 1; j <= m; j++) {
if (a[fun(i, j)] == -1 || f[fun(i, j)] != -1)
printf("X");
else
printf(".");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = (1 << 28);
const int N = (1 << 8) + 10;
const int M = 227 * 2;
int dp[N][M], w[M], dis[M][M], node[8];
int distrace[M][M], dptrace[N][M];
int cover[M][M];
int n, m, sum, nodenum;
int abs(int x) { return x < 0 ? -x : x; }
bool isconnect(int a, int b) {
int ax = a % m, ay = a / m;
int bx = b % m, by = b / m;
if (abs(ax - bx) + abs(ay - by) == 1) return true;
return false;
}
void floyd() {
fill(dis[0], dis[0] + M * M, oo);
for (int i = 0; i < sum; i++) {
for (int j = 0; j < sum; j++) {
if (i == j)
dis[i][j] = 0;
else if (isconnect(i, j))
dis[i][j] = w[j];
}
}
for (int k = 0; k < sum; k++)
for (int i = 0; i < sum; i++)
for (int j = 0; j < sum; j++) {
if (dis[i][j] > dis[i][k] + dis[k][j]) {
dis[i][j] = dis[i][k] + dis[k][j];
distrace[i][j] = k;
}
}
for (int i = 0; i < sum; i++)
for (int j = 0; j < sum; j++) dis[i][j] += w[i];
}
void setpath(int u, int v) {
cover[u / m][u % m] = cover[v / m][v % m] = 1;
if (distrace[u][v] == -1) return;
int pre = distrace[u][v];
setpath(u, pre);
setpath(pre, v);
}
void getpath(int set, int cur) {
if (dptrace[set][cur] == -1) return;
int pre = dptrace[set][cur];
if (!(set & (set - 1))) {
setpath(cur, pre - (1 << nodenum));
return;
}
if (pre >= (1 << nodenum)) {
setpath(pre - (1 << nodenum), cur);
getpath(set, pre - (1 << nodenum));
} else {
getpath(set ^ pre, cur);
getpath(pre, cur);
}
}
int main() {
while (scanf("%d %d %d", &n, &m, &nodenum) == 3) {
int x, y;
sum = n * m;
memset(cover, 0, sizeof(cover));
memset(dptrace, -1, sizeof(dptrace));
memset(distrace, -1, sizeof(distrace));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &w[i * m + j]);
}
}
for (int i = 0; i < nodenum; i++) {
scanf("%d %d", &y, &x);
y--, x--;
node[i] = y * m + x;
}
floyd();
fill(dp[0], dp[0] + N * M, oo);
for (int i = 0; i < sum; i++) {
for (int j = 0; j < nodenum; j++) {
dp[1 << j][i] = dis[i][node[j]];
dptrace[(1 << j)][i] = node[j] + (1 << nodenum);
}
}
for (int i = 0; i < (1 << nodenum); i++) {
for (int j = 0; j < sum; j++) {
for (int k = i & (i - 1); k; k = (k - 1) & i) {
int tmp = dp[i ^ k][j] + dp[k][j] - w[j];
if (dp[i][j] > tmp) {
dp[i][j] = tmp;
dptrace[i][j] = k;
}
}
}
for (int j = 0; j < sum; j++) {
for (int k = 0; k < sum; k++) {
int tmp = dp[i][k] + dis[k][j] - w[k];
if (dp[i][j] > tmp) {
dp[i][j] = tmp;
dptrace[i][j] = k + (1 << nodenum);
}
}
}
}
int ans = oo, ind = -1;
for (int i = 0; i < sum; i++) {
if (ans > dp[(1 << nodenum) - 1][i]) {
ans = dp[(1 << nodenum) - 1][i];
ind = i;
}
}
printf("%d\n", ans);
getpath((1 << nodenum) - 1, ind);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
printf("%c", cover[i][j] ? 'X' : '.');
}
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 210, INF = 1 * 1000 * 1000 * 1000 + 10, maxm = 150, maxk = 10;
int n, m, k, sar, now, par[maxn], x[maxk], c[maxn], d[maxn], f[maxn][maxn],
dp[maxm][maxn], dx[4] = {-1, 1, 0, 0}, dy[4] = {0, 0, -1, 1}, cur, X, Y,
save;
vector<int> t[maxm][maxn], path[maxn][maxn];
queue<int> q;
bool mark[maxn];
char ans[maxn][maxn];
inline bool valid(int &a, int &b) { return a >= 0 && a < n && b >= 0 && b < m; }
inline void SPFA() {
while (!q.empty()) {
sar = q.front();
X = sar / m;
Y = sar % m;
q.pop();
mark[sar] = 0;
for (int i = 0; i < 4; i++) {
X += dx[i];
Y += dy[i];
save = X * m + Y;
if (valid(X, Y) && d[save] > d[sar] + c[save]) {
d[save] = d[sar] + c[save];
par[save] = sar;
if (!mark[save]) {
q.push(save);
mark[save] = 1;
}
}
X -= dx[i];
Y -= dy[i];
}
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m >> k;
for (int i = 0; i < n * m; i++) cin >> c[i];
for (int i = 0; i < n * m; i++) {
for (int j = 0; j < n * m; j++) d[j] = INF;
d[i] = 0;
par[i] = -1;
mark[i] = 1;
q.push(i);
SPFA();
for (int j = 0; j < n * m; j++) {
f[i][j] = d[j];
now = j;
while (par[now] != -1) {
path[i][j].push_back(now);
now = par[now];
}
}
}
memset(dp, 63, sizeof dp);
for (int i = 0; i < k; i++) {
cin >> X >> Y;
X--;
Y--;
x[i] = X * m + Y;
for (int j = 0; j < n * m; j++) {
dp[1 << i][j] = f[x[i]][j] + c[x[i]];
t[1 << i][j] = path[x[i]][j];
t[1 << i][j].push_back(x[i]);
}
}
for (int i = 3; i < (1 << k); i++) {
if (__builtin_popcount(i) > 1) {
for (int j = 0; j < n * m; j++) {
for (int sub = i; sub; sub = (sub - 1) & i) {
if (sub == i) continue;
cur = i ^ sub;
for (int p = 0; p < n * m; p++) {
if (dp[sub][p] + dp[cur][p] + f[p][j] - c[p] < dp[i][j]) {
dp[i][j] = dp[sub][p] + dp[cur][p] + f[p][j] - c[p];
save = sub;
X = p;
}
}
}
cur = i ^ save;
t[i][j] = path[X][j];
for (int p = 0; p < ((int(t[save][X].size()))); p++)
t[i][j].push_back(t[save][X][p]);
for (int p = 0; p < ((int(t[cur][X].size()))); p++) {
if (t[cur][X][p] != X) t[i][j].push_back(t[cur][X][p]);
}
}
}
}
cout << dp[(1 << k) - 1][x[0]];
for (int i = 0; i < ((int(t[(1 << k) - 1][x[0]].size()))); i++)
ans[t[(1 << k) - 1][x[0]][i] / m][t[(1 << k) - 1][x[0]][i] % m] = 'X';
for (int i = 0; i < n; i++) {
cout << endl;
for (int j = 0; j < m; j++) {
if (ans[i][j] == 'X')
cout << ans[i][j];
else
cout << '.';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void in(int &x) {
x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
}
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
int n, m, k, a[105][105], dp[105][105][1 << 7], pre[105][105][1 << 7][3], X[10],
Y[10];
bool ans[105][105];
void draw(int x, int y, int mask) {
ans[x][y] = 1;
if (pre[x][y][mask][0] == 0) {
draw(pre[x][y][mask][1], pre[x][y][mask][2], mask);
} else if (pre[x][y][mask][0] == 1) {
draw(x, y, pre[x][y][mask][1]);
draw(x, y, pre[x][y][mask][2]);
}
}
int main() {
in(n);
in(m);
in(k);
for (int mask = 0; mask < (1 << k); mask++)
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) dp[i][j][mask] = 1e9;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) in(a[i][j]);
for (int i = 0; i < k; i++) {
in(X[i]);
in(Y[i]);
X[i]--;
Y[i]--;
pre[X[i]][Y[i]][1 << i][0] = 2;
dp[X[i]][Y[i]][1 << i] = a[X[i]][Y[i]];
}
for (int mask = 0; mask < (1 << k); mask++) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int sub = mask; sub; sub = (sub - 1) & mask) {
int tmp = dp[i][j][sub] + dp[i][j][mask ^ sub] - a[i][j];
if (tmp < dp[i][j][mask]) {
dp[i][j][mask] = tmp;
pre[i][j][mask][0] = 1;
pre[i][j][mask][1] = sub;
pre[i][j][mask][2] = mask ^ sub;
}
}
for (int T = 0; T < n * m + 10; T++) {
for (int x = 0; x < n; x++)
for (int y = 0; y < m; y++)
for (int i = 0; i < 4; i++) {
int nx = x + dx[i], ny = y + dy[i];
if (nx >= 0 && nx < n && ny >= 0 && ny < m) {
int tmp = dp[nx][ny][mask] + a[x][y];
if (tmp < dp[x][y][mask]) {
dp[x][y][mask] = tmp;
pre[x][y][mask][0] = 0;
pre[x][y][mask][1] = nx;
pre[x][y][mask][2] = ny;
}
}
}
}
}
int best = 1e9;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
best = min(dp[i][j][(1 << k) - 1], best);
}
printf("%d\n", best);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (dp[i][j][(1 << k) - 1] == best) {
draw(i, j, (1 << k) - 1);
for (int ii = 0; ii < n; ii++) {
for (int jj = 0; jj < m; jj++) putchar(ans[ii][jj] ? 'X' : '.');
putchar('\n');
}
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int DX[8] = {1, -1, 0, 0, 1, 1, -1, -1};
const int DY[8] = {0, 0, 1, -1, 1, -1, 1, -1};
const int intmax = 0x7fffffff;
int mp[105][105], n, m, nk;
int d[105][105][1 << 7];
pair<int, int> fa1[105][105][1 << 7], fa2[105][105][1 << 7];
char f[105][105];
bool vis[105][105];
struct node {
int x, y;
node(int a, int b) : x(a), y(b) {}
};
queue<node> qu;
inline int pow2(int n) { return 1 << n; }
inline int get2(int n, int p) { return (1 << p) & n; }
void print(int x, int y, int k) {
f[x][y] = 'X';
if (fa1[x][y][k].first == -1)
if (fa2[x][y][k].second == -1)
return;
else {
print(x, y, fa2[x][y][k].first);
print(x, y, fa2[x][y][k].second);
}
else
print(fa1[x][y][k].first, fa1[x][y][k].second, k);
}
int main() {
scanf("%d%d%d", &n, &m, &nk);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &mp[i][j]);
memset(d, 0x3f, sizeof(d));
for (int i = 0; i < nk; i++) {
int a, b;
scanf("%d%d", &a, &b);
d[a - 1][b - 1][pow2(i)] = mp[a - 1][b - 1];
fa1[a - 1][b - 1][pow2(i)] = make_pair(-1, -1);
fa2[a - 1][b - 1][pow2(i)] = make_pair(-1, -1);
}
for (int i = 1; i < pow2(nk); i++) {
for (int j = 0; j < n; j++)
for (int k = 0; k < m; k++)
for (int l = (i - 1) & i; l; l = (l - 1) & i) {
d[j][k][i] = min(d[j][k][i], d[j][k][l ^ i] + d[j][k][l] - mp[j][k]);
if (d[j][k][i] == d[j][k][l ^ i] + d[j][k][l] - mp[j][k]) {
fa1[j][k][i] = make_pair(-1, -1);
fa2[j][k][i] = make_pair(l ^ i, l);
}
}
for (int j = 0; j < n; j++)
for (int k = 0; k < m; k++) qu.push(node(j, k));
memset(vis, 0, sizeof(vis));
while (!qu.empty()) {
node tmp = qu.front();
qu.pop();
int x = tmp.x;
int y = tmp.y;
int dis = d[x][y][i];
vis[x][y] = 0;
for (int di = 0; di < 4; di++) {
int nx = x + DX[di];
int ny = y + DY[di];
if (nx < n && nx >= 0 && ny < m && ny >= 0) {
if (dis + mp[nx][ny] < d[nx][ny][i]) {
d[nx][ny][i] = dis + mp[nx][ny];
fa1[nx][ny][i] = make_pair(x, y);
fa2[nx][ny][i] = make_pair(-1, -1);
if (!vis[nx][ny]) {
qu.push(node(nx, ny));
vis[nx][ny] = 1;
}
}
}
}
}
}
int ans = intmax;
int ansx, ansy;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
ans = min(ans, d[i][j][pow2(nk) - 1]), f[i][j] = '.';
if (ans == d[i][j][pow2(nk) - 1]) ansx = i, ansy = j;
}
printf("%d\n", ans);
print(ansx, ansy, pow2(nk) - 1);
for (int i = 0; i < n; i++) puts(f[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int dx[4] = {0, 1, 0, -1};
const int dy[4] = {1, 0, -1, 0};
int f[201][201][201], px[201][201][201], py[201][201][201], x1[201][201][201];
int x2[201][201][201], dat[201][201], n, m, k;
int qx[3000000], qy[3000000], qz[3000000], l, r;
bool used[300][300];
void search(int x, int y, int z) {
used[x][y] = true;
if (x == 0 || y == 0) return;
if (x1[x][y][z] == 0) {
search(px[x][y][z], py[x][y][z], z);
} else {
search(px[x][y][z], py[x][y][z], x1[x][y][z]);
search(px[x][y][z], py[x][y][z], x2[x][y][z]);
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) scanf("%d", &dat[i][j]);
memset(f, 50, sizeof(f));
for (int i = 1; i <= k; ++i) {
int x, y;
scanf("%d%d", &x, &y);
qx[++r] = x;
qy[r] = y;
qz[r] = (1 << (i - 1));
f[x][y][1 << (i - 1)] = dat[x][y];
}
while (l < r) {
++l;
int x = qx[l], y = qy[l], z = qz[l];
for (int i = 1; i < (1 << k); ++i) {
if (f[x][y][z] + f[x][y][i] - dat[x][y] < f[x][y][z | i]) {
f[x][y][z | i] = f[x][y][z] + f[x][y][i] - dat[x][y];
qx[++r] = x;
qy[r] = y;
qz[r] = z | i;
px[x][y][z | i] = x;
py[x][y][z | i] = y;
x1[x][y][z | i] = z;
x2[x][y][z | i] = i;
}
}
for (int i = 0; i < 4; ++i) {
int xx = x + dx[i], yy = y + dy[i];
if (xx > 0 && xx <= n && yy > 0 && yy <= m &&
f[x][y][z] + dat[xx][yy] < f[xx][yy][z]) {
qx[++r] = xx;
qy[r] = yy;
qz[r] = z;
f[xx][yy][z] = f[x][y][z] + dat[xx][yy];
px[xx][yy][z] = x;
py[xx][yy][z] = y;
x1[xx][yy][z] = 0;
x2[xx][yy][z] = 0;
}
}
}
int maxx = 1000000000, xxx, yyy;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (f[i][j][(1 << k) - 1] < maxx)
maxx = f[i][j][(1 << k) - 1], xxx = i, yyy = j;
search(xxx, yyy, (1 << k) - 1);
cout << maxx << endl;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j)
if (used[i][j])
printf("X");
else
printf(".");
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nn = 110;
const int inf = 0x3fffffff;
int n, m, k;
int a[nn][nn];
int dp[(1 << 7) + 10][nn][nn];
bool use[nn][nn];
int dir[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
struct node {
int mask, x, y;
node() {}
node(int mmask, int xx, int yy) { mask = mmask, x = xx, y = yy; }
};
node pre[(1 << 7) + 10][nn][nn];
queue<node> que;
bool inque[(1 << 7) + 10][nn][nn];
void solve(int mask, int x, int y) {
if (pre[mask][x][y].mask == -1) return;
if (pre[mask][x][y].mask == 0) {
solve(pre[mask][x][y].x, x, y);
solve(pre[mask][x][y].y, x, y);
} else {
use[x][y] = true;
solve(mask, pre[mask][x][y].x, pre[mask][x][y].y);
}
}
int main() {
int i, j, x, y, e;
while (scanf("%d%d%d", &n, &m, &k) != EOF) {
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) scanf("%d", &a[i][j]);
memset(use, false, sizeof(use));
memset(inque, false, sizeof(inque));
for (e = 0; e < (1 << k); e++) {
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
dp[e][i][j] = inf;
pre[e][i][j] = node(-1, -1, -1);
}
}
}
for (i = 0; i < k; i++) {
scanf("%d%d", &x, &y);
dp[(1 << i)][x][y] = a[x][y];
use[x][y] = true;
que.push(node(1 << i, x, y));
inque[(1 << i)][x][y] = true;
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (!use[i][j]) {
dp[0][i][j] = a[i][j];
que.push(node(0, i, j));
inque[0][i][j] = true;
}
}
}
node sta;
while (que.size()) {
sta = que.front();
que.pop();
inque[sta.mask][sta.x][sta.y] = false;
for (e = 1; e < (1 << k); e++) {
if ((e & sta.mask) == 0) {
if (dp[e ^ sta.mask][sta.x][sta.y] > dp[sta.mask][sta.x][sta.y] +
dp[e][sta.x][sta.y] -
a[sta.x][sta.y]) {
pre[e ^ sta.mask][sta.x][sta.y] = node(0, sta.mask, e);
dp[e ^ sta.mask][sta.x][sta.y] = dp[sta.mask][sta.x][sta.y] +
dp[e][sta.x][sta.y] -
a[sta.x][sta.y];
if (!inque[e ^ sta.mask][sta.x][sta.y]) {
inque[e ^ sta.mask][sta.x][sta.y] = true;
que.push(node(e ^ sta.mask, sta.x, sta.y));
}
}
}
}
for (i = 0; i < 4; i++) {
int dx = sta.x + dir[i][0];
int dy = sta.y + dir[i][1];
if (dx >= 1 && dx <= n && dy >= 1 && dy <= m) {
if (dp[sta.mask][dx][dy] > dp[sta.mask][sta.x][sta.y] + a[dx][dy]) {
pre[sta.mask][dx][dy] = node(1, sta.x, sta.y);
dp[sta.mask][dx][dy] = dp[sta.mask][sta.x][sta.y] + a[dx][dy];
que.push(node(sta.mask, dx, dy));
inque[sta.mask][dx][dy] = true;
}
}
}
}
int ans = inf;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (dp[(1 << k) - 1][i][j] < ans) {
ans = dp[(1 << k) - 1][i][j];
sta = node((1 << k) - 1, i, j);
}
}
}
printf("%d\n", ans);
solve(sta.mask, sta.x, sta.y);
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
printf("%c", use[i][j] ? 'X' : '.');
}
puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int garden[100][100], n, m, k;
int dist[200][200], mid[200][200], f[1 << 6][200];
bool road[100][100];
struct Building {
int x, y, pos;
} build[7];
struct Path {
int mask1, mask2, pos;
void assign(int mask1, int mask2, int pos) {
this->mask1 = mask1;
this->mask2 = mask2;
this->pos = pos;
}
} path[1 << 6][200];
void output() {
int cost = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (road[i][j]) {
cost += garden[i][j];
}
}
}
cout << cost << endl;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << (road[i][j] ? 'X' : '.');
}
cout << endl;
}
}
void Floyd() {
int dir[4][2] = {0, -1, 0, 1, 1, 0, -1, 0}, nm = n * m;
for (int i = 0; i < nm; ++i) {
for (int j = 0; j < nm; ++j) {
dist[i][j] = (i == j ? 0 : 1000000000);
mid[i][j] = -1;
}
}
for (int i = 0; i < nm; ++i) {
int x = i / m, y = i % m;
for (int k = 0; k < 4; ++k) {
int rx = x + dir[k][0], ry = y + dir[k][1];
if (0 <= rx && rx < n && 0 <= ry && ry < m) {
dist[i][rx * m + ry] = garden[x][y];
}
}
}
for (int k = 0; k < nm; ++k) {
for (int i = 0; i < nm; ++i) {
for (int j = 0; j < nm; ++j) {
if (dist[i][k] + dist[k][j] < dist[i][j]) {
dist[i][j] = dist[i][k] + dist[k][j];
mid[i][j] = k;
}
}
}
}
}
void buildroad0(int x, int y) {
if (mid[x][y] == -1) {
road[x / m][x % m] = true;
} else {
buildroad0(x, mid[x][y]);
buildroad0(mid[x][y], y);
}
}
void buildroad(int mask, int pos) {
if (mask) {
buildroad(path[mask][pos].mask1, path[mask][pos].pos);
buildroad(path[mask][pos].mask2, path[mask][pos].pos);
buildroad0(path[mask][pos].pos, pos);
}
}
int main() {
while (cin >> n >> m >> k) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> garden[i][j];
}
}
for (int i = 0; i < k; ++i) {
cin >> build[i].x >> build[i].y;
--build[i].x, --build[i].y;
build[i].pos = build[i].x * m + build[i].y;
}
if (k == 1) {
road[build[0].x][build[0].y] = true;
output();
continue;
}
Floyd();
memset(f, 0x0f, sizeof(f));
int nm = n * m, k2 = 1 << (k - 1);
for (int i = 0; i < k - 1; ++i) {
for (int j = 0; j < nm; ++j) {
f[1 << i][j] = dist[build[i].pos][j];
path[1 << i][j].assign(0, 0, build[i].pos);
}
}
for (int mask1 = 1; mask1 < k2; ++mask1) {
for (int mask2 = 1; mask2 < k2; ++mask2) {
if ((mask1 & mask2) == 0) {
for (int pos1 = 0; pos1 < nm; ++pos1) {
for (int pos2 = 0; pos2 < nm; ++pos2) {
int d = dist[pos1][pos2] + f[mask1][pos1] + f[mask2][pos1];
if (d < f[mask1 | mask2][pos2]) {
f[mask1 | mask2][pos2] = d;
path[mask1 | mask2][pos2].assign(mask1, mask2, pos1);
}
}
}
}
}
}
buildroad(k2 - 1, build[k - 1].pos);
road[build[k - 1].x][build[k - 1].y] = true;
output();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int ans = 2e9, cnt, n, m, k, X, Y, a[110][110], Ans[110][110],
dis[110][110][130], path[110][110][130][3];
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
bool vis[110][110][130];
struct point {
int x, y, mask;
};
queue<point> q;
void draw(int x, int y, int mask) {
Ans[x][y] = 1;
if (path[x][y][mask][0] == 1) {
draw(path[x][y][mask][1], path[x][y][mask][2], mask);
}
if (path[x][y][mask][0] == 2) {
draw(x, y, path[x][y][mask][1]);
draw(x, y, path[x][y][mask][2]);
}
}
void SPFA() {
while (!q.empty()) {
point u = q.front();
q.pop();
vis[u.x][u.y][u.mask] = 0;
for (int i = 0; i < 4; i++) {
point v = (point){u.x + dx[i], u.y + dy[i], u.mask};
if (v.x < 1 || v.x > n || v.y < 1 || v.y > m) continue;
if (dis[v.x][v.y][v.mask] > dis[u.x][u.y][u.mask] + a[v.x][v.y]) {
dis[v.x][v.y][v.mask] = dis[u.x][u.y][u.mask] + a[v.x][v.y];
path[v.x][v.y][v.mask][0] = 1, path[v.x][v.y][v.mask][1] = u.x,
path[v.x][v.y][v.mask][2] = u.y;
if (!vis[v.x][v.y][v.mask]) vis[v.x][v.y][v.mask] = 1, q.push(v);
}
}
for (int i = 0; i < (1 << k); i++) {
if (i & u.mask) continue;
point v = (point){u.x, u.y, u.mask | i};
if (dis[v.x][v.y][v.mask] >
dis[u.x][u.y][u.mask] + dis[u.x][u.y][i] - a[u.x][u.y]) {
dis[v.x][v.y][v.mask] =
dis[u.x][u.y][u.mask] + dis[u.x][u.y][i] - a[u.x][u.y];
path[v.x][v.y][v.mask][0] = 2, path[v.x][v.y][v.mask][1] = i,
path[v.x][v.y][v.mask][2] = u.mask;
if (!vis[v.x][v.y][v.mask]) vis[v.x][v.y][v.mask] = 1, q.push(v);
}
}
}
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
memset(dis, 0x7f, sizeof(dis));
for (int i = 1, x, y; i <= k; i++) {
cin >> x >> y;
vis[x][y][1 << (i - 1)] = 1;
dis[x][y][1 << (i - 1)] = a[x][y];
q.push((point){x, y, 1 << (i - 1)});
}
SPFA();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (dis[i][j][(1 << k) - 1] < ans) {
ans = dis[i][j][(1 << k) - 1];
X = i;
Y = j;
}
}
}
draw(X, Y, (1 << k) - 1);
cout << ans << endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
putchar(Ans[i][j] ? 'X' : '.');
}
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
int n, m, k, p, a[7], c[205][205], z[205][205], d[128][205], h[128][205],
f[128][205], A = 1 << 29, R;
char o[205];
void fp(int i, int j) {
int t = z[i][j];
if (t < 0) return;
o[t] = 'X';
fp(i, t);
fp(t, j);
}
void trace(int i, int j) {
o[j] = 'X';
if (h[i][j] >= 0) {
trace(h[i][j], j);
trace(i ^ h[i][j], j);
}
if (f[i][j] >= 0 && f[i][j] != j) {
fp(j, f[i][j]);
trace(i, f[i][j]);
}
return;
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = (0); i < (n * m); i++)
for (int j = (0); j < (n * m); j++) c[i][j] = 1 << 29, z[i][j] = -1;
for (int i = (0); i < (1 << k); i++)
for (int j = (0); j < (n * m); j++)
d[i][j] = 1 << 29, h[i][j] = f[i][j] = -1;
for (int i = (0); i < (n * m); i++) o[i] = '.';
for (int i = (0); i < (n); i++)
for (int j = (0); j < (m); j++) {
scanf("%d", &c[p][p]);
p++;
}
p = 0;
for (int i = (0); i < (n); i++)
for (int j = (0); j < (m); j++) {
if (j < m - 1) c[p][p + 1] = c[p + 1][p] = c[p][p] + c[p + 1][p + 1];
if (i < n - 1) c[p][p + m] = c[p + m][p] = c[p][p] + c[p + m][p + m];
p++;
}
for (int t = (0); t < (p); t++)
for (int i = (0); i < (p); i++)
for (int j = (i + 1); j < (p); j++)
if (c[i][j] > c[i][t] + c[t][j] - c[t][t])
c[i][j] = c[j][i] = c[i][t] + c[t][j] - c[t][t],
z[i][j] = z[j][i] = t;
for (int i = (0); i < (k); i++) {
int x, y;
scanf("%d %d", &x, &y);
a[i] = (x - 1) * m + y - 1;
for (int j = (0); j < (p); j++)
d[1 << i][j] = c[a[i]][j], f[1 << i][j] = a[i];
}
for (int i = (3); i < (1 << k); i++) {
if ((i & -i) == i) continue;
for (int j = (0); j < (p); j++)
for (int t = i - 1 & i; t; t = t - 1 & i)
if (d[i][j] > d[t][j] + d[t ^ i][j] - c[j][j])
d[i][j] = d[t][j] + d[t ^ i][j] - c[j][j], h[i][j] = t;
for (int j = (0); j < (p); j++)
for (int t = (0); t < (p); t++)
if (d[i][j] > d[i][t] + c[t][j] - c[t][t])
d[i][j] = d[i][t] + c[t][j] - c[t][t], f[i][j] = t, h[i][j] = -1;
}
printf("%d\n", d[(1 << k) - 1][a[0]]);
trace((1 << k) - 1, a[0]);
for (int i = (0); i < (p); i++) {
putchar(o[i]);
if (i % m == m - 1) putchar('\n');
}
scanf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x[105][105], d[130][105][105], cnt[130], ans = INT_MAX, ta, tb, tc;
priority_queue<pair<int, pair<int, int> >, vector<pair<int, pair<int, int> > >,
greater<pair<int, pair<int, int> > > >
q[130];
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
bool u[105][105];
void go(int a, int b, int c) {
u[b][c] = 1;
if (d[a][b][c] == x[b][c]) return;
for (int i = 1; i * 2 < a; i++)
if ((i & a) == i && d[i][b][c] + d[a - i][b][c] - x[b][c] == d[a][b][c]) {
go(i, b, c);
go(a - i, b, c);
return;
}
int td = d[a][b][c] - x[b][c];
for (int i = 0; i < 4; i++) {
b += dx[i], c += dy[i];
if (b >= 0 && b < n && c >= 0 && c < m && d[a][b][c] == td) {
go(a, b, c);
return;
}
b -= dx[i], c -= dy[i];
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", x[i] + j);
for (int i = 0; i < k; i++) {
scanf("%d%d", &ta, &tb);
ta--, tb--;
q[1 << i].push(make_pair(d[1 << i][ta][tb] = x[ta][tb], make_pair(ta, tb)));
}
for (int i = 1; i < (1 << k); i++)
for (int j = 0; j < k; j++)
if (i & (1 << j)) cnt[i]++;
for (int i = 1; i <= k; i++)
for (int j = 1; j < (1 << k); j++) {
if (cnt[j] != i) continue;
for (int l = 1; l * 2 < j; l++)
if ((l & j) == l)
for (int ii = 0; ii < n; ii++)
for (int jj = 0; jj < m; jj++)
d[j][ii][jj] = min(d[j][ii][jj] ? d[j][ii][jj] : INT_MAX,
d[l][ii][jj] + d[j - l][ii][jj] - x[ii][jj]);
if (i == k) {
for (int ii = 0; ii < n; ii++)
for (int jj = 0; jj < m; jj++)
if (d[j][ii][jj] && d[j][ii][jj] < ans)
ans = d[j][ii][jj], ta = ii, tb = jj;
go(j, ta, tb);
continue;
}
if (i != 1)
for (int ii = 0; ii < n; ii++)
for (int jj = 0; jj < m; jj++)
q[j].push(make_pair(d[j][ii][jj], make_pair(ii, jj)));
while (!q[j].empty()) {
ta = q[j].top().second.first, tb = q[j].top().second.second,
tc = q[j].top().first;
q[j].pop();
if (d[j][ta][tb] != tc) continue;
for (int l = 0; l < 4; l++) {
ta += dx[l], tb += dy[l];
if (ta >= 0 && ta < n && tb >= 0 && tb < m &&
(!d[j][ta][tb] || tc + x[ta][tb] < d[j][ta][tb]))
q[j].push(
make_pair(d[j][ta][tb] = tc + x[ta][tb], make_pair(ta, tb)));
ta -= dx[l], tb -= dy[l];
}
}
}
printf("%d\n", ans);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%c", u[i][j] ? 'X' : '.');
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100 + 10;
const int MAX_V = 200 + 10;
const int MAX_S = 1 << 7;
const int INF = 1000000;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
int N, M, K, S;
int w[MAX_N][MAX_N];
int f[MAX_N][MAX_N][MAX_S];
int pre[MAX_N][MAX_N][MAX_S];
int qx[MAX_V];
int qy[MAX_V];
int in[MAX_N][MAX_N];
int cov[MAX_N][MAX_N];
void Init() {
int x, y;
scanf("%d%d%d", &N, &M, &K);
S = 1 << K;
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= M; ++j) scanf("%d", &w[i][j]);
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= M; ++j)
for (int k = 1; k < S; ++k) {
f[i][j][k] = INF;
pre[i][j][k] = INF;
}
for (int i = 0; i < K; ++i) {
scanf("%d%d", &x, &y);
f[x][y][1 << i] = w[x][y];
}
}
void SPFA(int s) {
int qh = 0, qt = 0;
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= M; ++j) {
qx[qt] = i;
qy[qt++] = j;
in[i][j] = true;
}
int nx, ny, px, py;
for (; qh < qt;) {
px = qx[qh];
py = qy[qh++];
for (int i = 0; i < 4; ++i) {
nx = px + dx[i];
ny = py + dy[i];
if (nx > 0 && nx <= N && ny > 0 && ny <= M &&
f[nx][ny][s] > f[px][py][s] + w[nx][ny]) {
f[nx][ny][s] = f[px][py][s] + w[nx][ny];
pre[nx][ny][s] = -i;
if (!in[nx][ny]) {
in[nx][ny] = true;
qx[qt] = nx;
qy[qt++] = ny;
}
}
}
in[px][py] = false;
}
}
void DFS(int x, int y, int s) {
cov[x][y] = true;
int tmp = pre[x][y][s];
if (tmp == INF) return;
if (tmp <= 0)
DFS(x - dx[-tmp], y - dy[-tmp], s);
else
DFS(x, y, tmp), DFS(x, y, s - tmp);
}
void Solve() {
for (int s = 1; s < S; ++s) {
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= M; ++j)
for (int ns = (s - 1) & s; ns; ns = (ns - 1) & s)
if (f[i][j][s] > f[i][j][ns] + f[i][j][s - ns] - w[i][j]) {
f[i][j][s] = f[i][j][ns] + f[i][j][s - ns] - w[i][j];
pre[i][j][s] = ns;
}
SPFA(s);
if (0) {
printf("Now is state %d\n", s);
for (int i = 1; i <= N; ++i) {
for (int j = 1; j <= M; ++j) printf("%d ", f[i][j][s]);
printf("\n");
}
}
}
int ax, ay, ans = INF;
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= M; ++j)
if (f[i][j][S - 1] < ans) {
ans = f[i][j][S - 1];
ax = i, ay = j;
}
printf("%d\n", ans);
DFS(ax, ay, S - 1);
for (int i = 1; i <= N; ++i) {
for (int j = 1; j <= M; ++j) putchar(cov[i][j] ? 'X' : '.');
putchar('\n');
}
}
int main() {
Init();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const lim = 220;
int mn[lim + 3][lim + 3], mid[lim + 3][lim + 3];
int inf = INT_MAX / 2;
int dp[(1 << 8)][lim + 3], inp[lim + 3], from[(1 << 8)][lim + 3], m;
bool is[(1 << 8)][lim + 3];
bool out[lim + 3];
void shortest(int u, int v) {
out[u] = out[v] = true;
int ind = mid[u][v];
if (ind == -1) return;
shortest(u, ind);
shortest(ind, v);
}
void solve(int mask, int u) {
out[u] = true;
int v = from[mask][u];
if (v == -1) return;
if (is[mask][u])
shortest(u, v), solve(mask, v);
else
solve(mask ^ v, u), solve(v, u);
}
int main() {
memset(mid, -1, sizeof mid);
memset(from, -1, sizeof from);
int n, m, kk;
cin >> n >> m >> kk;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &inp[i * m + j]);
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++) mn[i][j] = inf;
for (int i = 0; i < (1 << kk); i++)
for (int j = 0; j < n * m; j++) dp[i][j] = inf;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (i) mn[i * m + j][(i - 1) * m + j] = inp[(i - 1) * m + j];
if (j) mn[i * m + j][i * m + j - 1] = inp[i * m + j - 1];
if (i < n - 1) mn[i * m + j][(i + 1) * m + j] = inp[(i + 1) * m + j];
if (j < m - 1) mn[i * m + j][i * m + j + 1] = inp[i * m + j + 1];
}
for (int k = 0; k < n * m; k++)
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++)
if (mn[i][k] + mn[k][j] < mn[i][j])
mn[i][j] = mn[i][k] + mn[k][j], mid[i][j] = k;
for (int i = 0; i < kk; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
dp[(1 << i)][x * m + y] = inp[x * m + y];
for (int j = 0; j < n * m; j++)
if (inp[x * m + y] + mn[x * m + y][j] < dp[(1 << i)][j])
dp[(1 << i)][j] = inp[x * m + y] + mn[x * m + y][j],
from[(1 << i)][j] = x * m + y, is[(1 << i)][j] = true;
}
int ans = inf, ind = -1;
for (int i = 1; i < (1 << kk); i++) {
for (int k = 0; k < n * m; k++) {
for (int j = 1; j < (1 << kk); j++) {
if (((~i) & j) > 0) continue;
if (dp[j][k] + dp[i ^ j][k] - inp[k] < dp[i][k])
dp[i][k] = dp[j][k] + dp[i ^ j][k] - inp[k], from[i][k] = j,
is[i][k] = false;
}
for (int j = 0; j < n * m; j++)
if (dp[i][k] + mn[k][j] < dp[i][j])
dp[i][j] = dp[i][k] + mn[k][j], from[i][j] = k, is[i][j] = true;
if (i == (1 << kk) - 1 && dp[i][k] < ans)
ans = min(ans, dp[i][k]), ind = k;
}
}
solve((1 << kk) - 1, ind);
cout << ans << endl;
for (int i = 0; i < n; i++, puts(""))
for (int j = 0; j < m; j++)
if (out[i * m + j])
printf("X");
else
printf(".");
}
|
#include <bits/stdc++.h>
using namespace std;
char mmap[1110][1110];
queue<int> qu;
int n, m, k, st[1110], nn, mm, ans;
int in[1110][1110], pre[1110][1110];
int cost[1110][1110], arr[1110][1110];
int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
void Initial() {
ans = (1 << 29);
nn = (1 << k), mm = n * m;
for (int i = 0; i < nn; ++i)
for (int j = 0; j < mm; ++j) cost[j][i] = (1 << 29);
memset(st, 0, sizeof(st));
memset(in, 0, sizeof(in));
memset(pre, -1, sizeof(pre));
}
void Update(int u, int nst, int w, int fa) {
if (cost[u][nst] > w) {
cost[u][nst] = w;
pre[u][nst] = fa;
if (!in[u][nst]) {
in[u][nst] = 1;
qu.push(u * 1110 + nst);
}
}
}
int Check(int x, int y) { return x >= 0 && x < n && y >= 0 && y < m; }
void Steiner_Tree() {
int i, j, t, u, nst;
int xx, yy, x, y;
while (!qu.empty()) {
u = qu.front() / 1110;
nst = qu.front() % 1110;
x = u / m, y = u % m;
qu.pop(), in[u][nst] = 0;
for (i = 0; i < 4; ++i) {
xx = x + dir[i][0];
yy = y + dir[i][1];
if (Check(xx, yy) == 0) continue;
t = xx * m + yy;
Update(t, nst | st[t], cost[u][nst] + arr[xx][yy], u * 1110 + nst);
}
t = nn - 1 - nst;
for (i = (t - 1) & t; i; i = (i - 1) & t)
Update(u, nst | i, cost[u][nst] + cost[u][i] - arr[x][y], u * 1110 + nst);
}
}
void Find_Path(int u, int nst) {
int x = u / m, y = u % m;
mmap[x][y] = 'X';
if (pre[u][nst] == -1) return;
int uu = pre[u][nst] / 1110;
int nnst = pre[u][nst] % 1110;
Find_Path(uu, nnst);
if (nst - nnst) Find_Path(uu, nst - nnst);
}
void Solve_DP() {
int i, u, nst;
for (i = 0; i < mm; ++i)
if (cost[i][nn - 1] < ans) {
ans = cost[i][nn - 1];
u = i;
}
Find_Path(u, nn - 1);
}
int main() {
int i, j, t, x, y;
while (scanf("%d%d%d", &n, &m, &k) != EOF) {
Initial();
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j) {
scanf("%d", &arr[i][j]);
mmap[i][j] = '.';
}
for (i = 0; i < k; ++i) {
scanf("%d%d", &x, &y);
x--, y--;
t = x * m + y;
st[t] = (1 << i);
Update(t, st[t], arr[x][y], -1);
}
Steiner_Tree();
Solve_DP();
printf("%d\n", ans);
for (i = 0; i < n; ++i) printf("%s\n", mmap[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int steps = 300;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, 1, 0, -1};
int n, m;
bool need[110][110];
char out[110][110];
int a[110][110], num[110][110];
int d[130][110][110], tp[130][110][110], gomask[130][110][110],
gox[130][110][110], goy[130][110][110];
inline bool good(int x, int y) { return x >= 0 && x < n && y >= 0 && y < m; }
void path(int mask, int x, int y) {
if (tp[mask][x][y] == 1) {
out[x][y] = 'X';
return;
}
if (tp[mask][x][y] == 2) {
path(gomask[mask][x][y], x, y);
path(mask ^ gomask[mask][x][y], gox[mask][x][y], goy[mask][x][y]);
return;
}
path(mask, gox[mask][x][y], goy[mask][x][y]);
out[x][y] = 'X';
}
int main() {
int k;
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
}
}
for (int i = 0; i < k; i++) {
int x, y;
scanf("%d %d", &x, &y);
x--;
y--;
need[x][y] = true;
num[x][y] = i;
}
int all = (1 << k);
for (int i = 0; i < all; i++) {
for (int j = 0; j < n; j++) {
for (int z = 0; z < m; z++) {
d[i][j][z] = inf;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (need[i][j]) {
d[(1 << num[i][j])][i][j] = a[i][j];
tp[(1 << num[i][j])][i][j] = 1;
}
}
}
for (int i = 0; i < all; i++) {
for (int j = 0; j < n; j++) {
for (int z = 0; z < m; z++) {
for (int h = 0; h < 4; h++) {
int x = j + dx[h], y = z + dy[h];
if (!good(x, y)) {
continue;
}
for (int t = i; t > 0; t = (t - 1) & i) {
if (t == i) {
continue;
}
int res = d[t][j][z] + d[i ^ t][x][y];
if (res < d[i][j][z]) {
d[i][j][z] = res;
tp[i][j][z] = 2;
gomask[i][j][z] = t;
gox[i][j][z] = x;
goy[i][j][z] = y;
}
}
}
}
}
for (int h = 0; h < steps; h++) {
for (int j = 0; j < n; j++) {
for (int z = 0; z < m; z++) {
for (int t = 0; t < 4; t++) {
int x = j + dx[t], y = z + dy[t];
if (!good(x, y)) {
continue;
}
int res = d[i][x][y] + a[j][z];
if (res < d[i][j][z]) {
d[i][j][z] = res;
tp[i][j][z] = 3;
gox[i][j][z] = x;
goy[i][j][z] = y;
}
}
}
}
}
}
int ans = inf, x, y;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (d[all - 1][i][j] < ans) {
ans = d[all - 1][i][j];
x = i;
y = j;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
out[i][j] = '.';
}
}
path(all - 1, x, y);
printf("%d\n", ans);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
printf("%c", out[i][j]);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100, MAX_K = 7, INF = 0x3F3F3F3F;
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
int n, m, cnt, bd;
int maz[MAX_N][MAX_N], st[MAX_N][MAX_N];
int F[MAX_N][MAX_N][(1 << (MAX_K))];
int pre[MAX_N][MAX_N][(1 << (MAX_K))];
bool inq[MAX_N][MAX_N][(1 << (MAX_K))], vis[MAX_N][MAX_N];
queue<int> Q;
void DFS(int x, int y, int bm) {
vis[x][y] = 1;
if (!pre[x][y][bm]) return;
int tx = pre[x][y][bm] >> 24, ty = (pre[x][y][bm] >> 12) & ((1 << (12)) - 1),
tbm = pre[x][y][bm] & ((1 << (12)) - 1);
DFS(tx, ty, tbm);
if (x == tx && y == ty) DFS(tx, ty, (bm - tbm) | st[x][y]);
}
int main() {
cin >> n >> m >> cnt;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
cin >> maz[i][j];
}
for (int i = 0, x, y; i < cnt; ++i) {
cin >> x >> y;
--x;
--y;
st[x][y] = (1 << (i));
bd += maz[x][y];
maz[x][y] = 0;
}
memset(F, 0x3F, sizeof F);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (st[i][j]) F[i][j][st[i][j]] = 0;
for (int bm = 1; bm < (1 << (cnt)); ++bm) {
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
if (st[i][j] && !(bm & st[i][j])) continue;
for (int sbm = (bm - 1) & bm; sbm; sbm = (sbm - 1) & bm) {
int tmp = F[i][j][sbm | st[i][j]] + F[i][j][(bm - sbm) | st[i][j]] -
maz[i][j];
if (tmp < F[i][j][bm])
F[i][j][bm] = tmp,
pre[i][j][bm] = (((i) << 24) + ((j) << 12) + ((sbm | st[i][j])));
}
if (F[i][j][bm] < INF)
Q.push((((i) << 24) + ((j) << 12) + (bm))), inq[i][j][bm] = 1;
}
while (!Q.empty()) {
int x = Q.front() >> 24;
int y = (Q.front() >> 12) & ((1 << (12)) - 1);
int bm = Q.front() & ((1 << (12)) - 1);
Q.pop();
inq[x][y][bm] = 0;
for (int i = 0; i < 4; ++i) {
int tx = x + dx[i], ty = y + dy[i];
if (tx >= n || ty >= m || tx < 0 || ty < 0) continue;
int tbm = bm | st[tx][ty];
if (F[x][y][bm] + maz[tx][ty] < F[tx][ty][tbm]) {
F[tx][ty][tbm] = F[x][y][bm] + maz[tx][ty];
pre[tx][ty][tbm] = (((x) << 24) + ((y) << 12) + (bm));
if (!inq[tx][ty][tbm] && bm == tbm)
Q.push((((tx) << 24) + ((ty) << 12) + (tbm))), inq[tx][ty][tbm] = 1;
}
}
}
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (st[i][j]) {
cout << F[i][j][(1 << (cnt)) - 1] + bd << endl;
DFS(i, j, (1 << (cnt)) - 1);
for (int x = 0; x < n; ++x) {
for (int y = 0; y < m; ++y) {
if (st[x][y] || vis[x][y])
putchar('X');
else
putchar('.');
}
putchar('\n');
}
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int a[1000][1000];
int dp[(1 << 7) + 100][100][100];
bool vis[10000][10000];
int dir[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
struct node {
int mask, x, y;
};
node pre[(1 << 7) + 100][100][100];
queue<node> Q;
bool vis2[(1 << 7) + 100][100][100];
void solve(int mask, int x, int y) {
if (pre[mask][x][y].mask == -1) return;
if (pre[mask][x][y].mask == 0) {
solve(pre[mask][x][y].x, x, y);
solve(pre[mask][x][y].y, x, y);
} else {
vis[x][y] = true;
solve(mask, pre[mask][x][y].x, pre[mask][x][y].y);
}
}
int main() {
int x, y;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
}
}
for (int mask = 0; mask < (1 << k); mask++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dp[mask][i][j] = 999999999;
pre[mask][i][j] = node{-1, -1, -1};
}
}
}
for (int i = 0; i < k; i++) {
scanf("%d%d", &x, &y);
dp[(1 << i)][x][y] = a[x][y];
vis[x][y] = true;
Q.push(node{1 << i, x, y});
vis2[(1 << i)][x][y] = true;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (!vis[i][j]) {
dp[0][i][j] = a[i][j];
Q.push(node{0, i, j});
vis2[0][i][j] = true;
}
}
}
node sta;
while (!Q.empty()) {
sta = Q.front();
Q.pop();
vis2[sta.mask][sta.x][sta.y] = false;
for (int mask = 1; mask < (1 << k); mask++) {
if ((mask & sta.mask) == 0) {
if (dp[mask + sta.mask][sta.x][sta.y] > dp[sta.mask][sta.x][sta.y] +
dp[mask][sta.x][sta.y] -
a[sta.x][sta.y]) {
pre[mask + sta.mask][sta.x][sta.y] = node{0, sta.mask, mask};
dp[mask + sta.mask][sta.x][sta.y] = dp[sta.mask][sta.x][sta.y] +
dp[mask][sta.x][sta.y] -
a[sta.x][sta.y];
if (!vis2[mask + sta.mask][sta.x][sta.y]) {
vis2[mask + sta.mask][sta.x][sta.y] = true;
Q.push(node{mask + sta.mask, sta.x, sta.y});
}
}
}
}
for (int i = 0; i < 4; i++) {
int dx = sta.x + dir[i][0];
int dy = sta.y + dir[i][1];
if (dx >= 1 && dx <= n && dy >= 1 && dy <= m) {
if (dp[sta.mask][dx][dy] > dp[sta.mask][sta.x][sta.y] + a[dx][dy]) {
pre[sta.mask][dx][dy] = node{1, sta.x, sta.y};
dp[sta.mask][dx][dy] = dp[sta.mask][sta.x][sta.y] + a[dx][dy];
Q.push(node{sta.mask, dx, dy});
vis2[sta.mask][dx][dy] = true;
}
}
}
}
int ans = 999999999;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (dp[(1 << k) - 1][i][j] < ans) {
ans = dp[(1 << k) - 1][i][j];
sta = node{(1 << k) - 1, i, j};
}
}
}
printf("%d\n", ans);
solve(sta.mask, sta.x, sta.y);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
printf("%c", vis[i][j] ? 'X' : '.');
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int L(int i) { return i << 1; }
inline int R(int i) { return (i << 1) | 1; }
inline int B(int i) { return 1 << i; }
inline int low_bit(int x) { return x & (-x); }
struct node {
int x, y;
} pre[128][211];
int n, m, k, dp[128][211], st, mn, q[1000100], top, val[211], v[211];
char mat[211][211];
int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
void dfs(int state, int id) {
int x = id / n, y = id % n, u = pre[state][id].x, v = pre[state][id].y;
mat[x][y] = 'X';
if (u) dfs(u, v);
if (u && u != state) dfs(u ^ state, v);
}
int inboard(int x, int y) { return 0 <= x && x < m && 0 <= y && y < n; }
void spfa() {
for (int i = 1; i <= st; i++) {
for (int u = 0; u < mn; u++)
for (int v = i & (i - 1); v; v = i & (v - 1)) {
int vv = dp[v][u] + dp[i ^ v][u] - val[u];
if (vv < dp[i][u]) dp[i][u] = vv, pre[i][u].x = v, pre[i][u].y = u;
}
top = mn;
for (int j = 0; j < mn; j++) q[j] = j, v[j] = 1;
for (int j = 0; j < top; j++) {
int now = q[j], to, vv;
v[now] = 0;
for (int u = 0; u < 4; u++) {
int x = now / n + dir[u][0], y = now % n + dir[u][1];
if (inboard(x, y)) {
to = x * n + y;
vv = dp[i][now] + val[to];
if (vv < dp[i][to]) {
dp[i][to] = vv, pre[i][to].x = i, pre[i][to].y = now;
if (!v[to]) {
q[top++] = to;
v[to] = 1;
}
}
}
}
}
}
}
int main() {
int x, y;
for (; ~scanf("%d%d%d", &m, &n, &k);) {
st = (1 << k) - 1;
mn = n * m;
memset(pre, 0, sizeof(pre));
memset(dp, 0x3f, sizeof(dp));
for (int i = 0; i < mn; i++) scanf("%d", &val[i]);
for (int i = 0; i < k; i++) {
scanf("%d%d", &x, &y);
--x, --y;
int t = x * n + y;
dp[1 << i][t] = val[t];
}
spfa();
int ret = 0x3ffffff, id;
for (int i = 0; i < mn; i++) {
if (ret > dp[st][i]) ret = dp[st][i], id = i;
}
printf("%d\n", ret);
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++) mat[i][j] = '.';
dfs(st, id);
for (int i = 0; i < m; i++, puts(""))
for (int j = 0; j < n; j++) printf("%c", mat[i][j]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int maxk = 10;
const int maxn = 105;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, -1, 0, 1};
int n, m, t, ax, ay;
int a[maxn][maxn];
int dp[1 << maxk][maxn][maxn];
bool ans[maxn][maxn];
pair<int, pair<int, int> > f[1 << maxk][maxn][maxn];
bool inMap(int x, int y) { return (x >= 0 && x < n && y >= 0 && y < m); }
bool id(int x, int y) { return x * m + y; }
void dijkstra(int msk) {
priority_queue<pair<int, pair<int, int> >,
vector<pair<int, pair<int, int> > >,
greater<pair<int, pair<int, int> > > >
q;
for (int x = (0); x < (n); ++x)
for (int y = (0); y < (m); ++y)
q.push(make_pair(dp[msk][x][y], make_pair(x, y)));
while (!q.empty()) {
int d = q.top().first;
int x = q.top().second.first, y = q.top().second.second;
q.pop();
if (dp[msk][x][y] != d) continue;
for (int k = (0); k < (4); ++k) {
int nx = x + dx[k], ny = y + dy[k];
if (!inMap(nx, ny)) continue;
if (dp[msk][nx][ny] > dp[msk][x][y] + a[nx][ny]) {
dp[msk][nx][ny] = dp[msk][x][y] + a[nx][ny];
q.push(make_pair(dp[msk][nx][ny], make_pair(nx, ny)));
f[msk][nx][ny] = make_pair(1, make_pair(x, y));
}
}
}
return;
}
void goBack(int msk, int x, int y) {
ans[x][y] = true;
if (~f[msk][x][y].first) {
if (!f[msk][x][y].first) {
goBack(f[msk][x][y].second.first, x, y);
goBack(f[msk][x][y].second.second, x, y);
} else
goBack(msk, f[msk][x][y].second.first, f[msk][x][y].second.second);
}
return;
}
int main() {
scanf("%d%d%d", &n, &m, &t);
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (m); ++j) scanf("%d", &a[i][j]);
for (int msk = (0); msk < (1 << t); ++msk)
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (m); ++j) dp[msk][i][j] = INF;
for (int i = (0); i < (t); ++i) {
int x, y;
scanf("%d%d", &x, &y);
--x;
--y;
dp[1 << i][x][y] = a[x][y];
f[1 << i][x][y] = make_pair(-1, make_pair(x, y));
}
for (int msk = (0); msk < (1 << t); ++msk) {
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (m); ++j) {
for (int mx = msk; mx; mx = ((mx - 1) & msk))
if (dp[mx][i][j] != INF && dp[msk ^ mx][i][j] != INF) {
int my = msk ^ mx;
if (dp[msk][i][j] > dp[mx][i][j] + dp[my][i][j] - a[i][j]) {
dp[msk][i][j] = dp[mx][i][j] + dp[my][i][j] - a[i][j];
f[msk][i][j] = make_pair(0, make_pair(mx, my));
}
}
}
dijkstra(msk);
}
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (m); ++j)
if (dp[(1 << t) - 1][i][j] < dp[(1 << t) - 1][ax][ay]) ax = i, ay = j;
printf("%d\n", dp[(1 << t) - 1][ax][ay]);
goBack((1 << t) - 1, ax, ay);
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < (m); ++j) putchar(ans[i][j] ? 'X' : '.');
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, s, M[128][128];
vector<vector<int> > dist[128][128];
vector<vector<pair<int, int> > > paidist[128][128];
short int terminal[128][128];
pair<int, int> S[12];
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int PD[(1 << 7)][101][101][2];
pair<int, pair<int, int> > pai[(1 << 7)][101][101][2];
char R[128][128];
inline void imprime() {
for (int i = 0; i < n; i++) printf("%s\n", R[i]);
}
void pinta_caminho(int i1, int j1, int i2, int j2) {
if (i1 == i2 and j1 == j2) {
R[i1][j1] = 'X';
return;
}
pair<int, int> p = paidist[i1][j1][i2][j2];
if (p.first == i1 and p.second == j1) {
R[i1][j1] = 'X';
R[i2][j2] = 'X';
return;
}
pinta_caminho(i1, j1, p.first, p.second);
pinta_caminho(p.first, p.second, i2, j2);
}
void pinta_arvore(int bm, int i, int j, int pfolha) {
if (bm == 0) {
R[i][j] = 'X';
return;
}
if (__builtin_popcount(bm) == 1) {
int t = __builtin_ctz(bm);
pinta_caminho(S[t].first, S[t].second, i, j);
return;
}
pair<int, pair<int, int> > u = pai[bm][i][j][pfolha];
int nbm = u.first;
int ni = u.second.first, nj = u.second.second;
if (bm != nbm) {
pinta_arvore(nbm, i, j, 1);
pinta_arvore(bm ^ nbm, i, j, 1);
return;
}
pinta_caminho(i, j, ni, nj);
pinta_arvore(bm, ni, nj, 0);
}
int calc(int bm, int i, int j, int pfolha) {
if (bm == 0) return M[i][j];
int &pd = PD[bm][i][j][pfolha];
pair<int, pair<int, int> > &papai = pai[bm][i][j][pfolha];
if (pd != -1) return pd;
if (__builtin_popcount(bm) == 1) {
int t = __builtin_ctz(bm);
return pd = dist[S[t].first][S[t].second][i][j];
}
int best = 0x3f3f3f3f;
int x = (bm - 1) & bm;
while (x) {
int t1 = calc(x, i, j, 1);
int t2 = calc(bm ^ x, i, j, 1);
int opc = t1 + t2 - (x ? M[i][j] : 0);
if (opc < best) {
best = opc;
papai = pair<int, pair<int, int> >(x, pair<int, int>(i, j));
}
x = (x - 1) & bm;
}
if (pfolha) {
for (int k = 0; k < n; k++)
for (int l = 0; l < m; l++)
if (k != i or l != j) {
int opc = dist[i][j][k][l] + calc(bm, k, l, 0) - M[k][l];
if (opc < best) {
best = opc;
papai = pair<int, pair<int, int> >(bm, pair<int, int>(k, l));
}
}
}
return pd = best;
}
int main() {
scanf("%d %d %d", &n, &m, &s);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
R[i][j] = '.';
dist[i][j].resize(n);
paidist[i][j].resize(n);
for (int k = 0; k < n; k++) {
dist[i][j][k].resize(m);
paidist[i][j][k].resize(m);
for (int l = 0; l < m; l++) dist[i][j][k][l] = 0x3f3f3f3f;
}
}
R[i][m] = '\0';
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
scanf("%d", &M[i][j]);
dist[i][j][i][j] = M[i][j];
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int k = 0; k < 4; k++) {
int ni = i + dx[k];
int nj = j + dy[k];
if (!(0 <= ni and ni < n and 0 <= nj and nj < m)) continue;
dist[i][j][ni][nj] = M[i][j] + M[ni][nj];
paidist[i][j][ni][nj] = pair<int, int>(i, j);
}
for (int k1 = 0; k1 < n; k1++)
for (int k2 = 0; k2 < m; k2++)
for (int i1 = 0; i1 < n; i1++)
for (int i2 = 0; i2 < m; i2++)
for (int j1 = 0; j1 < n; j1++)
for (int j2 = 0; j2 < m; j2++) {
int opc = dist[i1][i2][k1][k2] + dist[k1][k2][j1][j2] - M[k1][k2];
if (opc < dist[i1][i2][j1][j2]) {
dist[i1][i2][j1][j2] = opc;
paidist[i1][i2][j1][j2] = pair<int, int>(k1, k2);
}
}
memset(terminal, 0xff, sizeof(terminal));
for (int i = 0; i < s; i++) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
terminal[a][b] = i;
S[i] = pair<int, int>(a, b);
}
if (s == 1) {
printf("%d\n", M[S[0].first][S[0].second]);
R[S[0].first][S[0].second] = 'X';
imprime();
return 0;
}
if (s == 2) {
printf("%d\n", dist[S[0].first][S[0].second][S[1].first][S[1].second]);
pinta_caminho(S[0].first, S[0].second, S[1].first, S[1].second);
imprime();
return 0;
}
memset(PD, 0xff, sizeof(PD));
int resp = calc((1 << s) - 1, S[s - 1].first, S[s - 1].second, 1);
int bm = (1 << s) - 1, i = S[s - 1].first, j = S[s - 1].second, pf = 1;
pinta_arvore(bm, i, j, pf);
printf("%d\n", resp);
imprime();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t;
int n, m, k;
const int N = 110;
int a[N][N];
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
vector<int> e[N * N], val[N * N];
int dp[N * N][1 << 7];
vector<int> nodes[N * N][1 << 7];
bool u[N * N], ans[N * N];
struct ele {
int cost;
vector<int> node;
int vex;
};
bool operator<(ele x, ele y) { return x.cost > y.cost; }
priority_queue<ele> que;
void vclear(int i, int j) {
int t1 = (i - 1) * m + j;
e[t1].clear();
val[t1].clear();
}
void addedge(int i, int j, int tx, int ty, int w) {
int t1 = (i - 1) * m + j;
int t2 = (tx - 1) * m + ty;
e[t1].push_back(t2);
val[t1].push_back(w);
}
vector<int> uni(vector<int> a, vector<int> b) {
vector<int> ret;
for (auto v : a) ret.push_back(v);
for (auto v : b) ret.push_back(v);
return ret;
}
void dijkstra(int s) {
memset(u, 0, sizeof(u));
while (!que.empty()) {
ele tmp = que.top();
que.pop();
int tp = tmp.vex;
if (u[tp] == 1) continue;
u[tp] = 1;
dp[tp][s] = tmp.cost;
nodes[tp][s] = tmp.node;
for (int i = (0); i < (e[tp].size()); i++) {
int v = e[tp][i];
if (u[v] == 1) continue;
ele tt;
tt.vex = v;
tt.cost = tmp.cost + val[tp][i];
tt.node = tmp.node;
tt.node.push_back(v);
que.push(tt);
}
}
}
int main() {
while (cin >> n >> m >> k) {
int nn = n * m;
for (int i = (1); i < (n + 1); i++)
for (int j = (1); j < (m + 1); j++) {
cin >> a[i][j];
vclear(i, j);
}
for (int i = (1); i < (n + 1); i++)
for (int j = (1); j < (m + 1); j++) {
for (int _ = (0); _ < (4); _++) {
int tx = i + dx[_];
int ty = j + dy[_];
if (tx < 1 || tx > n || ty < 1 || ty > m) continue;
addedge(i, j, tx, ty, a[tx][ty]);
}
}
memset(dp, 0x3f, sizeof(dp));
int tpos;
for (int i = (1); i < (k + 1); i++) {
int tx, ty;
cin >> tx >> ty;
int pos = (tx - 1) * m + ty;
tpos = pos;
dp[pos][1 << (i - 1)] = a[tx][ty];
nodes[pos][1 << (i - 1)].clear();
nodes[pos][1 << (i - 1)].push_back(pos);
}
for (int s = (1); s < (1 << k); s++) {
for (int ii = (1); ii < (n + 1); ii++)
for (int jj = (1); jj < (m + 1); jj++) {
int i = (ii - 1) * m + jj;
for (int sub = s & (s - 1); sub; sub = s & (sub - 1)) {
if (dp[i][s] > dp[i][sub] + dp[i][s ^ sub] - a[ii][jj]) {
dp[i][s] = dp[i][sub] + dp[i][s ^ sub] - a[ii][jj];
nodes[i][s] = uni(nodes[i][sub], nodes[i][s ^ sub]);
}
}
if (dp[i][s] != -1) {
ele tmp;
tmp.cost = dp[i][s];
tmp.node = nodes[i][s];
tmp.vex = i;
que.push(tmp);
}
}
dijkstra(s);
}
cout << dp[tpos][(1 << k) - 1] << '\n';
memset(ans, 0, sizeof(ans));
for (auto v : nodes[tpos][(1 << k) - 1]) ans[v] = 1;
int tt = 0;
for (int i = (1); i < (n + 1); i++) {
for (int j = (1); j < (m + 1); j++) {
int pos = (i - 1) * m + j;
if (ans[pos] == 1)
cout << 'X';
else
cout << '.';
}
cout << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0},
bi[11] = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024};
const int mn = 210, ml = 3001000, inf = 1 << 30;
int f[mn][mn], fa[mn][mn], x1[mn][mn], x2[mn][mn];
int a[mn][mn], n, m, k;
int q[ml], qz[ml], l, r;
bool vis[mn][mn], g[mn][mn];
int pos(int x, int y) { return (x - 1) * m + y; }
void dfs(int r, int z) {
if (!r) return;
vis[(r - 1) / m + 1][(r - 1) % m + 1] = 1;
if (!x1[r][z]) {
dfs(fa[r][z], z);
return;
}
dfs(fa[r][z], x1[r][z]);
dfs(fa[r][z], x2[r][z]);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
int i, j, x, y, z, u, v, ans = inf, t, p;
for (i = 1; i <= n; ++i)
for (j = 1; j <= m; ++j) scanf("%d", &a[i][j]);
fill(&f[0][0], &f[mn - 1][mn - 1], inf);
for (i = 1; i <= k; ++i) {
scanf("%d%d", &x, &y);
t = pos(x, y);
q[++r] = t, qz[r] = bi[i - 1];
f[t][bi[i - 1]] = a[x][y];
}
l = 1;
while (l <= r) {
x = (q[l] - 1) / m + 1, y = (q[l] - 1) % m + 1, z = qz[l];
t = pos(x, y);
for (i = 0; i <= bi[k] - 1; ++i) {
if (f[t][z] + f[t][i] - a[x][y] < f[t][z | i]) {
f[t][z | i] = f[t][z] + f[t][i] - a[x][y];
fa[t][z | i] = t;
x1[t][z | i] = z, x2[t][z | i] = i;
if (!g[t][z | i]) {
q[++r] = t, qz[r] = z | i;
}
}
}
for (i = 0; i <= 3; ++i) {
u = x + dx[i], v = y + dy[i];
if (u < 1 || u > n || v < 1 || v > m) continue;
p = pos(u, v);
if (f[t][z] + a[u][v] < f[p][z]) {
f[p][z] = f[t][z] + a[u][v];
fa[p][z] = t;
x1[p][z] = x2[p][z] = 0;
if (!g[p][z]) {
q[++r] = p, qz[r] = z;
}
}
}
++l;
}
for (i = 1; i <= n * m; ++i)
if (f[i][bi[k] - 1] < ans) ans = f[i][bi[k] - 1], x = i;
dfs(x, bi[k] - 1);
printf("%d\n", ans);
for (i = 1; i <= n; ++i) {
for (j = 1; j <= m; ++j) printf("%c", vis[i][j] ? 'X' : '.');
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int wayx[4] = {0, 0, -1, 1};
const int wayy[4] = {1, -1, 0, 0};
int n, m, k;
int a[110][110];
int c[110][110];
int f[110][110][1 << 7];
int pp[110][110][1 << 7];
int b[110][110];
const int inf = 1e9;
struct node {
int x, y, s, z;
friend bool operator<(node a, node b) { return a.z > b.z; }
};
vector<node> way[110][110][1 << 7];
priority_queue<node> q;
queue<node> tmp;
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &a[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int l = 0; l < (1 << k); l++) f[i][j][l] = inf;
for (int i = 1; i <= k; i++) {
int x, y;
scanf("%d %d", &x, &y);
c[x][y] = 1 << (i - 1);
f[x][y][c[x][y]] = a[x][y];
q.push({x, y, c[x][y], a[x][y]});
}
while (!q.empty()) {
node p = q.top();
q.pop();
if (pp[p.x][p.y][p.s]) continue;
pp[p.x][p.y][p.s] = 1;
for (int i = 0; i < 4; i++) {
int nx = p.x + wayx[i], ny = p.y + wayy[i], ns;
if (nx < 1 || nx > n || ny < 1 || ny > m) continue;
ns = p.s | c[nx][ny];
if (f[nx][ny][ns] > p.z + a[nx][ny]) {
f[nx][ny][ns] = p.z + a[nx][ny];
way[nx][ny][ns].clear();
way[nx][ny][ns].push_back({p.x, p.y, p.s});
q.push({nx, ny, ns, f[nx][ny][ns]});
}
}
int cf = (~p.s) & ((1 << k) - 1);
for (int i = cf; i; i = (i - 1) & cf) {
int nx = p.x, ny = p.y, ns = p.s | i;
if (f[nx][ny][i] == inf) continue;
if (f[nx][ny][ns] > p.z + f[nx][ny][i] - a[nx][ny]) {
f[nx][ny][ns] = p.z + f[nx][ny][i] - a[nx][ny];
way[nx][ny][ns].clear();
way[nx][ny][ns].push_back({nx, ny, p.s});
way[nx][ny][ns].push_back({nx, ny, i});
q.push({nx, ny, ns, f[nx][ny][ns]});
}
}
}
int ans = inf;
node p;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (ans > f[i][j][(1 << k) - 1]) {
ans = min(ans, f[i][j][(1 << k) - 1]);
p = {i, j, (1 << k) - 1};
}
}
printf("%d\n", ans);
tmp.push(p);
while (!tmp.empty()) {
node p = tmp.front();
tmp.pop();
b[p.x][p.y] = 1;
for (int i = 0; i < way[p.x][p.y][p.s].size(); i++)
tmp.push(way[p.x][p.y][p.s][i]);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
if (b[i][j])
printf("X");
else
printf(".");
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, s, M[128][128];
vector<vector<int> > dist[128][128];
vector<vector<pair<int, int> > > paidist[128][128];
short int terminal[128][128];
pair<int, int> S[12];
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int PD[(1 << 7)][101][101][2];
bool split[(1 << 7)][101][101][2];
pair<pair<int, int>, pair<int, int> > pai[(1 << 7)][101][101][2];
char R[128][128];
inline void imprime() {
for (int i = 0; i < n; i++) printf("%s\n", R[i]);
}
void pinta_caminho(int i1, int j1, int i2, int j2) {
if (i1 == i2 and j1 == j2) {
R[i1][j1] = 'X';
return;
}
pair<int, int> p = paidist[i1][j1][i2][j2];
if (p.first == i1 and p.second == j1) {
R[i1][j1] = 'X';
R[i2][j2] = 'X';
return;
}
pinta_caminho(i1, j1, p.first, p.second);
pinta_caminho(p.first, p.second, i2, j2);
}
void pinta_arvore(int bm, int i, int j, int pfolha) {
if (bm == 0) {
R[i][j] = 'X';
return;
}
if (__builtin_popcount(bm) == 1) {
int t = __builtin_ctz(bm);
pinta_caminho(S[t].first, S[t].second, i, j);
return;
}
pair<pair<int, int>, pair<int, int> > u = pai[bm][i][j][pfolha];
int nbm = u.first.first, npfolha = u.first.second;
int ni = u.second.first, nj = u.second.second;
if (split[bm][i][j][pfolha]) {
pinta_arvore(nbm, i, j, npfolha);
pinta_arvore(bm ^ nbm, i, j, npfolha);
return;
}
pinta_caminho(i, j, ni, nj);
pinta_arvore(nbm, ni, nj, npfolha);
}
int calc(int bm, int i, int j, int pfolha) {
if (bm == 0) return M[i][j];
int &pd = PD[bm][i][j][pfolha];
pair<pair<int, int>, pair<int, int> > &papai = pai[bm][i][j][pfolha];
bool &sp = split[bm][i][j][pfolha];
if (pd != -1) return pd;
if (__builtin_popcount(bm) == 1) {
int t = __builtin_ctz(bm);
return pd = dist[S[t].first][S[t].second][i][j];
}
int best = 0x3f3f3f3f;
int x = (bm - 1) & bm;
while (x) {
int t1 = calc(x, i, j, 1);
int t2 = calc(bm ^ x, i, j, 1);
int opc = t1 + t2 - M[i][j];
if (opc < best) {
best = opc;
papai = pair<pair<int, int>, pair<int, int> >(pair<int, int>(x, 1),
pair<int, int>(i, j));
sp = true;
}
x = (x - 1) & bm;
}
if (pfolha) {
for (int k = 0; k < s; k++)
if (bm & (1 << k)) {
int opc = dist[i][j][S[k].first][S[k].second] +
calc(bm ^ (1 << k), S[k].first, S[k].second, 1) -
M[S[k].first][S[k].second];
if (opc < best) {
best = opc;
sp = false;
papai = pair<pair<int, int>, pair<int, int> >(
pair<int, int>(bm ^ (1 << k), 1),
pair<int, int>(S[k].first, S[k].second));
}
}
for (int k = 0; k < n; k++)
for (int l = 0; l < m; l++)
if ((k != i or l != j) and terminal[k][l] < 0) {
int opc = dist[i][j][k][l] + calc(bm, k, l, 0) - M[k][l];
if (opc < best) {
best = opc;
sp = false;
papai = pair<pair<int, int>, pair<int, int> >(pair<int, int>(bm, 0),
pair<int, int>(k, l));
}
}
}
return pd = best;
}
int main() {
scanf("%d %d %d", &n, &m, &s);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
R[i][j] = '.';
dist[i][j].resize(n);
paidist[i][j].resize(n);
for (int k = 0; k < n; k++) {
dist[i][j][k].resize(m);
paidist[i][j][k].resize(m);
for (int l = 0; l < m; l++) dist[i][j][k][l] = 0x3f3f3f3f;
}
}
R[i][m] = '\0';
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
scanf("%d", &M[i][j]);
dist[i][j][i][j] = M[i][j];
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int k = 0; k < 4; k++) {
int ni = i + dx[k];
int nj = j + dy[k];
if (!(0 <= ni and ni < n and 0 <= nj and nj < m)) continue;
dist[i][j][ni][nj] = M[i][j] + M[ni][nj];
paidist[i][j][ni][nj] = pair<int, int>(i, j);
}
for (int k1 = 0; k1 < n; k1++)
for (int k2 = 0; k2 < m; k2++)
for (int i1 = 0; i1 < n; i1++)
for (int i2 = 0; i2 < m; i2++)
for (int j1 = 0; j1 < n; j1++)
for (int j2 = 0; j2 < m; j2++) {
int opc = dist[i1][i2][k1][k2] + dist[k1][k2][j1][j2] - M[k1][k2];
if (opc < dist[i1][i2][j1][j2]) {
dist[i1][i2][j1][j2] = opc;
paidist[i1][i2][j1][j2] = pair<int, int>(k1, k2);
}
}
memset(terminal, 0xff, sizeof(terminal));
for (int i = 0; i < s; i++) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
terminal[a][b] = i;
S[i] = pair<int, int>(a, b);
}
if (s == 1) {
printf("%d\n", M[S[0].first][S[0].second]);
R[S[0].first][S[0].second] = 'X';
imprime();
return 0;
}
if (s == 2) {
printf("%d\n", dist[S[0].first][S[0].second][S[1].first][S[1].second]);
pinta_caminho(S[0].first, S[0].second, S[1].first, S[1].second);
imprime();
return 0;
}
memset(PD, 0xff, sizeof(PD));
int resp = calc((1 << s) - 1 - 1, S[0].first, S[0].second, 1);
int bm = (1 << s) - 1 - 1, i = S[0].first, j = S[0].second, pf = 1;
pinta_arvore(bm, i, j, pf);
printf("%d\n", resp);
imprime();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
template <typename T>
using lim = numeric_limits<T>;
template <typename T>
istream& operator>>(istream& is, vector<T>& a) {
for (T& x : a) {
is >> x;
}
return is;
}
template <typename T>
struct grid : public vector<vector<T>> {
int n, m;
grid(int n, int m) : vector<vector<T>>(n, vector<T>(m)), n(n), m(m) {}
grid(int n, int m, T zero)
: vector<vector<T>>(n, vector<T>(m, zero)), n(n), m(m) {}
grid(const grid& a) : vector<vector<T>>(a), n(a.n), m(a.m) {}
};
const int N = 100, K = 7, INF = 1000 * N * N;
int a[N + 1][N + 1], x[K], y[K], opt[1 << K][N + 1][N + 1],
pred_mask[1 << K][N + 1][N + 1], pred_i[1 << K][N + 1][N + 1],
pred_j[1 << K][N + 1][N + 1];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
grid<grid<int>> d(n + 1, m + 1, grid<int>(n + 1, m + 1));
grid<grid<int>> through_i(n + 1, m + 1, grid<int>(n + 1, m + 1));
grid<grid<int>> through_j(n + 1, m + 1, grid<int>(n + 1, m + 1));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int ii = 1; ii <= n; ii++) {
for (int jj = 1; jj <= m; jj++) {
d[i][j][ii][jj] = INF;
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
d[i][j][i][j] = a[i][j];
for (int di = -1; di <= 1; di++) {
for (int dj = -1; dj <= 1; dj++) {
int ni = i + di, nj = j + dj;
if (abs(di) + abs(dj) == 1 and 1 <= ni and ni <= n and 1 <= nj and
nj <= m) {
d[i][j][ni][nj] = a[i][j] + a[ni][nj];
}
}
}
}
}
for (int i = 0; i < k; i++) {
cin >> x[i] >> y[i];
}
for (int kx = 1; kx <= n; kx++) {
for (int ky = 1; ky <= m; ky++) {
for (int ix = 1; ix <= n; ix++) {
for (int iy = 1; iy <= m; iy++) {
for (int jx = 1; jx <= n; jx++) {
for (int jy = 1; jy <= m; jy++) {
if (d[ix][iy][jx][jy] >
d[ix][iy][kx][ky] + d[kx][ky][jx][jy] - a[kx][ky]) {
d[ix][iy][jx][jy] =
d[ix][iy][kx][ky] + d[kx][ky][jx][jy] - a[kx][ky];
through_i[ix][iy][jx][jy] = kx;
through_j[ix][iy][jx][jy] = ky;
}
}
}
}
}
}
}
for (int mask = 1; mask < 1 << k; mask++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (__builtin_popcount(mask) == 1) {
opt[mask][i][j] =
d[x[__builtin_ctz(mask)]][y[__builtin_ctz(mask)]][i][j];
} else {
opt[mask][i][j] = lim<int>::max();
for (int x = (mask - 1) & mask; x > 0; x = (x - 1) & mask) {
for (int ii = 1; ii <= n; ii++) {
for (int jj = 1; jj <= m; jj++) {
if (opt[mask][i][j] > opt[x][ii][jj] + opt[mask ^ x][ii][jj] +
d[ii][jj][i][j] - 2 * a[ii][jj]) {
opt[mask][i][j] = opt[x][ii][jj] + opt[mask ^ x][ii][jj] +
d[ii][jj][i][j] - 2 * a[ii][jj];
pred_mask[mask][i][j] = x, pred_i[mask][i][j] = ii,
pred_j[mask][i][j] = jj;
}
}
}
}
}
}
}
}
int ans = lim<int>::max(), opt_i = 0, opt_j = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (ans > opt[(1 << k) - 1][i][j]) {
ans = opt[(1 << k) - 1][i][j];
opt_i = i, opt_j = j;
}
}
}
function<void(int, int, int, int)> mark_path = [&](int i, int j, int ii,
int jj) {
if (abs(ii - i) + abs(jj - j) <= 1) {
a[i][j] = a[ii][jj] = 0;
} else {
mark_path(i, j, through_i[i][j][ii][jj], through_j[i][j][ii][jj]);
mark_path(through_i[i][j][ii][jj], through_j[i][j][ii][jj], ii, jj);
}
};
function<void(int, int, int)> construct_path = [&](int mask, int i, int j) {
if (__builtin_popcount(mask) == 1) {
mark_path(x[__builtin_ctz(mask)], y[__builtin_ctz(mask)], i, j);
} else {
mark_path(i, j, pred_i[mask][i][j], pred_j[mask][i][j]);
construct_path(pred_mask[mask][i][j], pred_i[mask][i][j],
pred_j[mask][i][j]);
construct_path(mask ^ pred_mask[mask][i][j], pred_i[mask][i][j],
pred_j[mask][i][j]);
}
};
construct_path((1 << k) - 1, opt_i, opt_j);
cout << ans << endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cout << (a[i][j] ? '.' : 'X');
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {0, 0, -1, 1}, dy[] = {1, -1, 0, 0};
struct node {
int x, y, sta, cost;
} p, now;
int n, m, k, a[105][105], dp[105][105][135], c[105][105], ans = 0x7fffffff;
bool inq[105][105][135], use[105][105];
priority_queue<node> q;
vector<node> way[105][105][135];
queue<node> tmp;
bool operator<(node a, node b) { return a.cost > b.cost; }
inline void read(int& x) {
x = 0;
char c = getchar();
while (c > '9' || c < '0') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
}
int main() {
read(n), read(m), read(k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) read(a[i][j]);
memset(dp, 0x3f, sizeof(dp));
for (int i = 0, x, y; i < k; i++) {
read(x), read(y);
c[x][y] = 1 << i;
dp[x][y][c[x][y]] = a[x][y];
q.push((node){x, y, c[x][y], a[x][y]});
}
while (!q.empty()) {
now = q.top();
q.pop();
if (inq[now.x][now.y][now.sta]) continue;
inq[now.x][now.y][now.sta] = 1;
for (int i = 0; i < 4; i++) {
int xx = now.x + dx[i], yy = now.y + dy[i], sta;
if (xx < 1 || xx > n || yy < 1 || yy > m) continue;
sta = now.sta | c[xx][yy];
if (dp[xx][yy][sta] > now.cost + a[xx][yy]) {
dp[xx][yy][sta] = now.cost + a[xx][yy];
way[xx][yy][sta].clear();
way[xx][yy][sta].push_back(now);
q.push((node){xx, yy, sta, dp[xx][yy][sta]});
}
}
int cf = ((1 << k) - 1) & (~now.sta);
for (int i = cf; i; i = (i - 1) & cf) {
int xx = now.x, yy = now.y, sta = now.sta | i;
if (dp[xx][yy][i] == 0x3f3f3f3f) continue;
if (dp[xx][yy][sta] > dp[xx][yy][i] + now.cost - a[xx][yy]) {
dp[xx][yy][sta] = dp[xx][yy][i] + now.cost - a[xx][yy];
way[xx][yy][sta].clear();
way[xx][yy][sta].push_back((node){xx, yy, i});
way[xx][yy][sta].push_back((node){xx, yy, now.sta});
q.push((node){xx, yy, sta, dp[xx][yy][sta]});
}
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (ans > dp[i][j][(1 << k) - 1])
ans = dp[i][j][(1 << k) - 1], p = (node){i, j, (1 << k) - 1};
printf("%d\n", ans);
tmp.push(p);
while (!tmp.empty()) {
p = tmp.front();
tmp.pop();
use[p.x][p.y] = 1;
for (int i = 0; i < way[p.x][p.y][p.sta].size(); i++)
tmp.push(way[p.x][p.y][p.sta][i]);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) putchar(use[i][j] ? 'X' : '.');
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7f7f7f7f;
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, 1, 0, -1};
int n, m, k, cnt;
int cost[110][110], num[110][110], px[10], py[10];
int d[210][1 << 7], inq[210][1 << 7], pre[210][1 << 7][2];
char grid[110][110];
queue<pair<int, int> > q;
inline int checkmin(int &a, int b) { return b < a ? (a = b), 1 : 0; }
void spfa() {
for (int i = 0; i < k; i++)
pre[num[px[i]][py[i]]][1 << i][0] = -1, pre[num[px[i]][py[i]]][0][0] = -1,
d[num[px[i]][py[i]]][1 << i] =
cost[px[i]][py[i]],
inq[num[px[i]][py[i]]][1 << i] = 1,
q.push(
pair<int, int>(num[px[i]][py[i]], 1 << i));
while (!q.empty()) {
pair<int, int> t = q.front();
q.pop();
inq[t.first][t.second] = 0;
int qx = (t.first - 1) / m + 1, qy = (t.first - 1) % m + 1;
for (int i = 0; i < 4; i++) {
int tn = num[qx + dx[i]][qy + dy[i]];
if (!tn || d[tn][0] >= INF) continue;
if (checkmin(d[tn][t.second], d[t.first][t.second] + d[tn][0])) {
pre[tn][t.second][0] = 0, pre[tn][t.second][1] = t.first;
if (!inq[tn][t.second])
q.push(pair<int, int>(tn, t.second)), inq[tn][t.second] = 1;
}
}
for (int i = 0; i < (1 << k); i++)
if (d[t.first][i] < INF && !(i & t.second))
if (checkmin(d[t.first][i | t.second],
d[t.first][i] + d[t.first][t.second] - cost[qx][qy])) {
pre[t.first][i | t.second][0] = 1;
pre[t.first][i | t.second][1] = i;
if (!inq[t.first][i | t.second])
q.push(pair<int, int>(t.first, i | t.second)),
inq[t.first][i | t.second] = 1;
}
}
}
void getAns(int pos, int mask) {
grid[(pos - 1) / m + 1][(pos - 1) % m + 1] = 'X';
if (pre[pos][mask][0] == -1) return;
if (pre[pos][mask][0])
getAns(pos, pre[pos][mask][1]), getAns(pos, mask ^ pre[pos][mask][1]);
else
getAns(pre[pos][mask][1], mask);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
scanf("%d", &cost[i][j]), num[i][j] = ++cnt, grid[i][j] = '.';
for (int i = 0; i < k; i++) scanf("%d%d", &px[i], &py[i]);
memset(d, 0x7f, sizeof(d));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) d[num[i][j]][0] = cost[i][j];
spfa();
int ans = INF, ansx, ansy;
for (int i = 1; i <= cnt; i++)
if (checkmin(ans, d[i][(1 << k) - 1])) ansx = i, ansy = (1 << k) - 1;
printf("%d\n", ans);
getAns(ansx, ansy);
for (int i = 1; i <= n; i++) puts(grid[i] + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 128;
int dx[4] = {0, 0, -1, 1};
int dy[4] = {-1, 1, 0, 0};
int N, M, K;
int x[maxn], y[maxn], a[maxn][maxn];
int dp[maxn][maxn][maxn], path[maxn][maxn][maxn][3];
string ans[maxn];
void bellman_ford(int mask) {
for (int iter = 0; iter < N * M + 10; iter++) {
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++)
for (int k = 0; k < 4; k++) {
int xx = i + dx[k], yy = j + dy[k];
if (xx >= 0 && xx < N && yy >= 0 && yy < M) {
int tmp = dp[i][j][mask] + a[xx][yy];
if (tmp < dp[xx][yy][mask]) {
dp[xx][yy][mask] = tmp;
path[xx][yy][mask][0] = 0;
path[xx][yy][mask][1] = i;
path[xx][yy][mask][2] = j;
}
}
}
}
}
void Print(int xx, int yy, int mask) {
ans[xx][yy] = 'X';
if (path[xx][yy][mask][0] == 0)
Print(path[xx][yy][mask][1], path[xx][yy][mask][2], mask);
if (path[xx][yy][mask][0] == 1) {
Print(xx, yy, path[xx][yy][mask][1]);
Print(xx, yy, path[xx][yy][mask][2]);
}
}
int main() {
cin >> N >> M >> K;
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) cin >> a[i][j];
for (int i = 0; i < K; i++) {
cin >> x[i] >> y[i];
x[i]--;
y[i]--;
}
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++)
for (int k = 0; k < (1 << K); k++) dp[i][j][k] = (1 << 29);
for (int i = 0; i < K; i++) {
dp[x[i]][y[i]][1 << i] = a[x[i]][y[i]];
path[x[i]][y[i]][1 << i][0] = 2;
}
for (int mask = 0; mask < (1 << K); mask++) {
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) {
for (int mask2 = 0; mask2 < mask; mask2++)
if (!(~mask & mask2)) {
int tmp = dp[i][j][mask2] + dp[i][j][mask - mask2] - a[i][j];
if (tmp < dp[i][j][mask]) {
dp[i][j][mask] = tmp;
path[i][j][mask][0] = 1;
path[i][j][mask][1] = mask2;
path[i][j][mask][2] = mask - mask2;
}
}
}
bellman_ford(mask);
}
int ret = (1 << 29);
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) {
ret = min(ret, dp[i][j][(1 << K) - 1]);
}
cout << ret << endl;
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) ans[i] += '.';
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++)
if (dp[i][j][(1 << K) - 1] == ret) {
Print(i, j, (1 << K) - 1);
for (int k = 0; k < N; k++) cout << ans[k] << endl;
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class P, class Q>
inline void mmin(P &a, Q b) {
if (b < a) a = b;
}
template <class P, class Q>
inline void mmax(P &a, Q b) {
if (a < b) a = b;
}
const int MAXn = 200 + 5, MAXk = 7;
const int INF = 1e9;
int n, m, k;
int val[MAXn], imp[MAXk];
int dis[MAXn][MAXn];
int dp[1 << 7][MAXn];
bool mark[MAXn];
void solve(int mask, int i) {
mark[i] = true;
if ((mask - 1) & mask == 0 && dp[mask][i] == val[i]) return;
for (int sub = (mask - 1) & mask; sub; sub = (sub - 1) & mask) {
if (dp[mask][i] == dp[sub][i] + dp[mask ^ sub][i] - val[i]) {
solve(sub, i);
solve(mask ^ sub, i);
return;
}
}
if (i % m > 0 && dp[mask][i - 1] + val[i] == dp[mask][i]) {
solve(mask, i - 1);
return;
}
if (i % m < m - 1 && dp[mask][i + 1] + val[i] == dp[mask][i]) {
solve(mask, i + 1);
return;
}
if (i - m >= 0 && dp[mask][i - m] + val[i] == dp[mask][i]) {
solve(mask, i - m);
return;
}
if (i + m < n && dp[mask][i + m] + val[i] == dp[mask][i]) {
solve(mask, i + m);
return;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
n *= m;
for (int i = 0; i < n; ++i) cin >> val[i];
for (int i = 0; i < k; ++i) {
int x, y;
cin >> x >> y;
--x;
--y;
imp[i] = x * m + y;
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) {
if (i == j) {
dis[i][j] = 0;
continue;
}
dis[i][j] = INF;
if (i / m == j / m && abs(i - j) == 1) dis[i][j] = val[j];
if (i % m == j % m && abs(i - j) == m) dis[i][j] = val[j];
}
for (int z = 0; z < n; ++z)
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) mmin(dis[i][j], dis[i][z] + dis[z][j]);
for (int i = 0; i < 1 << k; ++i)
for (int j = 0; j < n; ++j) dp[i][j] = INF;
for (int i = 0; i < k; ++i) {
dp[1 << i][imp[i]] = val[imp[i]];
}
for (int mask = 1; mask < (1 << k); ++mask) {
for (int i = 0; i < n; ++i)
for (int sub = (mask - 1) & mask; sub; sub = (sub - 1) & mask)
mmin(dp[mask][i], dp[sub][i] + dp[mask ^ sub][i] - val[i]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) mmin(dp[mask][i], dp[mask][j] + dis[j][i]);
}
int ans = INF, umask = (1 << k) - 1, ui;
for (int i = 0; i < n; ++i)
if (dp[(1 << k) - 1][i] < ans) {
ui = i;
ans = dp[umask][ui];
}
cout << ans << endl;
solve(umask, ui);
for (int i = 0; i < n; ++i) {
cout << (mark[i] ? 'X' : '.');
if ((i + 1) % m == 0) cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int X, Y, K;
int x[10], y[10];
int a[110][110];
int dp[110][110][(1 << 7)], path[110][110][(1 << 7)][3];
int dx[4] = {1, -1, 0, 0}, dy[4] = {0, 0, 1, -1};
string ans[110];
void shortest(int mask) {
int iter, i, j, k;
for ((iter) = 0; (iter) < (int)(X * Y + 10); (iter)++) {
for ((i) = 0; (i) < (int)(X); (i)++)
for ((j) = 0; (j) < (int)(Y); (j)++)
for ((k) = 0; (k) < (int)(4); (k)++) {
int x2 = i + dx[k], y2 = j + dy[k];
if (x2 >= 0 && x2 < X && y2 >= 0 && y2 < Y) {
int tmp = dp[i][j][mask] + a[x2][y2];
if (tmp < dp[x2][y2][mask]) {
dp[x2][y2][mask] = tmp;
path[x2][y2][mask][0] = 0;
path[x2][y2][mask][1] = i;
path[x2][y2][mask][2] = j;
}
}
}
}
}
void print(int x2, int y2, int mask) {
ans[x2][y2] = 'X';
if (path[x2][y2][mask][0] == 0)
print(path[x2][y2][mask][1], path[x2][y2][mask][2], mask);
if (path[x2][y2][mask][0] == 1) {
print(x2, y2, path[x2][y2][mask][1]);
print(x2, y2, path[x2][y2][mask][2]);
}
}
int main(void) {
int i, j, k, mask;
cin >> X >> Y >> K;
for ((i) = 0; (i) < (int)(X); (i)++)
for ((j) = 0; (j) < (int)(Y); (j)++) cin >> a[i][j];
for ((i) = 0; (i) < (int)(K); (i)++) {
cin >> x[i] >> y[i];
x[i]--;
y[i]--;
}
for ((i) = 0; (i) < (int)(X); (i)++)
for ((j) = 0; (j) < (int)(Y); (j)++)
for ((mask) = 0; (mask) < (int)((1 << K)); (mask)++)
dp[i][j][mask] = (1 << 29);
for ((i) = 0; (i) < (int)(K); (i)++) {
dp[x[i]][y[i]][(1 << i)] = a[x[i]][y[i]];
path[x[i]][y[i]][(1 << i)][0] = 2;
}
for ((mask) = 0; (mask) < (int)((1 << K)); (mask)++) {
for ((i) = 0; (i) < (int)(X); (i)++)
for ((j) = 0; (j) < (int)(Y); (j)++) {
int mask2;
for (mask2 = mask; mask2 > 0; mask2 = (mask & (mask2 - 1))) {
int tmp = dp[i][j][mask2] + dp[i][j][mask ^ mask2] - a[i][j];
if (tmp < dp[i][j][mask]) {
dp[i][j][mask] = tmp;
path[i][j][mask][0] = 1;
path[i][j][mask][1] = mask2;
path[i][j][mask][2] = (mask ^ mask2);
}
}
}
shortest(mask);
}
int best = (1 << 29);
for ((i) = 0; (i) < (int)(X); (i)++)
for ((j) = 0; (j) < (int)(Y); (j)++)
best = min(best, dp[i][j][(1 << K) - 1]);
cout << best << endl;
for ((i) = 0; (i) < (int)(X); (i)++)
for ((j) = 0; (j) < (int)(Y); (j)++) ans[i] += '.';
for ((i) = 0; (i) < (int)(X); (i)++)
for ((j) = 0; (j) < (int)(Y); (j)++)
if (dp[i][j][(1 << K) - 1] == best) {
print(i, j, (1 << K) - 1);
for ((k) = 0; (k) < (int)(X); (k)++) cout << ans[k] << endl;
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
long long MAX(long long x, long long y) { return (x > y) ? x : y; }
long long MIN(long long x, long long y) { return (x < y) ? x : y; }
const int MAXN = 123;
const int MAXNM = 223;
const int MAXK = 7;
const int inf = 0x3f3f3f3f;
using namespace std;
inline int Read() {
register int x = 0;
bool flag = false;
register char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') flag = true;
ch = getchar();
}
if (flag) {
while ('0' <= ch && ch <= '9') {
x = x * 10 - ch + '0';
ch = getchar();
}
} else {
while ('0' <= ch && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
}
return x;
}
int N, M, K;
int cg(int x, int y) { return (x - 1) * M + y; }
pair<int, int> split(int z) {
int y = (z - 1) % M + 1;
return make_pair((z - y) / M + 1, y);
}
int dirx[4] = {1, 0, -1, 0};
int diry[4] = {0, 1, 0, -1};
int trans(int z, int dir) {
pair<int, int> p = split(z);
p = make_pair(p.first + dirx[dir], p.second + diry[dir]);
if (1 <= p.first && p.first <= N && 1 <= p.second && p.second <= M)
return cg(p.first, p.second);
else
return -1;
}
int a[MAXNM];
int f[MAXNM][(1 << MAXK) - 1];
vector<pair<int, int> > frm[MAXNM][(1 << MAXK) - 1];
int ele[MAXK];
queue<int> q;
bool inq[MAXNM];
void spfa(int s) {
while (!q.empty()) {
int hd = q.front();
q.pop();
inq[hd] = false;
for (int i = 0; i <= 3; i++) {
int v = trans(hd, i);
if (~v) {
if (f[v][s] > f[hd][s] + a[v]) {
f[v][s] = f[hd][s] + a[v];
frm[v][s].clear();
frm[v][s].push_back(make_pair(hd, s));
if (!inq[v]) {
q.push(v);
inq[v] = true;
}
}
}
}
}
}
char mp[MAXN][MAXN];
void print(int i, int s) {
pair<int, int> p = split(i);
mp[p.first][p.second] = 'X';
for (auto &v : frm[i][s]) print(v.first, v.second);
}
int main() {
memset(f, 0x3f, sizeof(f));
N = Read();
M = Read();
K = Read();
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++) mp[i][j] = '.';
for (int i = 1; i <= N * M; i++) a[i] = Read();
for (int i = 0; i <= K - 1; i++) {
int x = Read(), y = Read();
ele[i] = cg(x, y);
f[ele[i]][1 << i] = a[ele[i]];
}
for (int s = 1; s <= (1 << K) - 1; s++) {
for (int ss = s & (s - 1); ss; ss = s & (ss - 1))
for (int i = 1; i <= N * M; i++)
if (f[i][s] > f[i][ss] + f[i][s ^ ss] - a[i]) {
f[i][s] = f[i][ss] + f[i][s ^ ss] - a[i];
frm[i][s].clear();
frm[i][s].push_back(make_pair(i, ss));
frm[i][s].push_back(make_pair(i, s ^ ss));
}
for (int i = 1; i <= N * M; i++)
if (f[i][s] < inf) {
q.push(i);
inq[i] = true;
}
spfa(s);
}
int ans = inf, id;
for (int i = 1; i <= N * M; i++)
if (f[i][(1 << K) - 1] < ans) ans = f[id = i][(1 << K) - 1];
printf("%d\n", ans);
print(id, (1 << K) - 1);
for (int i = 1; i <= N; i++) printf("%s\n", mp[i] + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
const int K = 7;
int a[N], dp[1 << K][N];
bitset<N> mark[1 << K][N];
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
void upd(int msk, int u, int v) {
if (dp[msk][u] + a[v] < dp[msk][v]) {
dp[msk][v] = dp[msk][u] + a[v];
mark[msk][v] = mark[msk][u];
mark[msk][v][v] = 1;
pq.push(make_pair(dp[msk][v], v));
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i * m + j];
memset(dp, 63, sizeof dp);
for (int i = 0; i < k; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
int v = x * m + y;
dp[1 << i][v] = a[v];
mark[1 << i][v][v] = 1;
}
for (int msk = 1; msk < (1 << k); msk++) {
for (int v = 0; v < n * m; v++) {
for (int sub = (msk - 1) & msk; sub; sub = (sub - 1) & msk) {
int d = dp[sub][v] + dp[msk ^ sub][v] - a[v];
if (d < dp[msk][v]) {
dp[msk][v] = d;
mark[msk][v] = mark[sub][v] | mark[msk ^ sub][v];
}
}
pq.push(make_pair(dp[msk][v], v));
}
while (!pq.empty()) {
int v = pq.top().second, d = pq.top().first;
pq.pop();
if (dp[msk][v] != d) continue;
if (0 <= v - m) upd(msk, v, v - m);
if (v + m < n * m) upd(msk, v, v + m);
if (0 < v % m) upd(msk, v, v - 1);
if (v % m < m - 1) upd(msk, v, v + 1);
}
}
int v = 0;
for (int i = 0; i < n * m; i++)
if (dp[(1 << k) - 1][i] < dp[(1 << k) - 1][v]) v = i;
cout << dp[(1 << k) - 1][v] << '\n';
for (int i = 0; i < n; i++, cout << '\n')
for (int j = 0; j < m; j++)
cout << (mark[(1 << k) - 1][v][i * m + j] ? 'X' : '.');
return 0;
}
|
#include <bits/stdc++.h>
const int Q = 256000;
int dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, -1, 1};
int N, M, K, a[110][110];
int bit[110][110], f[110][110][138], pre[110][110][138], vis[110][110];
struct point {
int x, y, st;
point() {}
point(int _x, int _y, int _st) : x(_x), y(_y), st(_st) {}
} q[256010];
int front, rear, inq[110][110][138];
void init() {
int i, j, n = 0, x, y;
for (i = 1; i <= N; i++)
for (j = 1; j <= M; j++) scanf("%d", &a[i][j]);
for (i = 1; i <= N; i++)
for (j = 1; j <= M; j++)
bit[i][j] = 0, memset(f[i][j], 0x3f, sizeof(f[i][j])),
memset(pre[i][j], 0x3f, sizeof(pre[i][j]));
for (i = 0; i < K; i++) {
scanf("%d%d", &x, &y);
bit[x][y] = 1 << (n++), f[x][y][bit[x][y]] = a[x][y];
}
}
int can(int x, int y) { return x >= 1 && x <= N && y >= 1 && y <= M; }
void spfa() {
int i, x, y, st, nx, ny, nst;
while (front != rear) {
x = q[front].x, y = q[front].y, st = q[front].st, inq[x][y][st] = 0;
++front > Q ? front = 0 : 0;
for (i = 0; i < 4; i++) {
nx = dx[i] + x, ny = dy[i] + y, nst = st | bit[nx][ny];
if (can(nx, ny) && f[x][y][st] + a[nx][ny] < f[nx][ny][nst]) {
f[nx][ny][nst] = f[x][y][st] + a[nx][ny], pre[nx][ny][nst] = -i;
q[rear++] = point(nx, ny, nst), inq[nx][ny][nst] = 1;
rear > Q ? rear = 0 : 0;
}
}
}
}
void dfs(int x, int y, int st) {
vis[x][y] = 1;
if (pre[x][y][st] == 0x3f3f3f3f) return;
if (pre[x][y][st] <= 0)
dfs(x - dx[-pre[x][y][st]], y - dy[-pre[x][y][st]], st - bit[x][y]);
else
dfs(x, y, pre[x][y][st]), dfs(x, y, st - pre[x][y][st] | bit[x][y]);
}
void solve() {
int i, j, k, x, y, st, nn = 1 << K, ans;
front = rear = 0;
for (i = 1; i <= N; i++)
for (j = 1; j <= M; j++)
memset(inq[i][j], 0, sizeof(inq[i][j])), vis[i][j] = 0;
for (i = 0; i < nn; i++) {
for (j = 1; j <= N; j++)
for (k = 1; k <= M; k++) {
for (st = i & i - 1; st; st = st - 1 & i) {
int temp =
f[j][k][st | bit[j][k]] + f[j][k][i - st | bit[j][k]] - a[j][k];
if (temp < f[j][k][i])
f[j][k][i] = temp, pre[j][k][i] = st | bit[j][k];
}
if (f[j][k][i] < 0x3f3f3f3f) {
q[rear++] = point(j, k, i), inq[j][k][i] = 1;
rear > Q ? rear = 0 : 0;
}
}
spfa();
}
ans = 0x3f3f3f3f;
for (i = 1; i <= N; i++)
for (j = 1; j <= M; j++)
if (f[i][j][nn - 1] < ans) ans = f[i][j][nn - 1], x = i, y = j;
dfs(x, y, nn - 1);
printf("%d\n", ans);
for (i = 1; i <= N; i++) {
for (j = 1; j <= M; j++) printf("%c", vis[i][j] ? 'X' : '.');
printf("\n");
}
}
int main() {
while (scanf("%d%d%d", &N, &M, &K) == 3) {
init();
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, K;
int P[110][110], C[110][2], T[110][110];
int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
int D[110][110][(1 << 7) + 10];
bool in[110][110], cov[110][110];
pair<int, pair<int, int> > pre[110][110][(1 << 7) + 10];
queue<pair<int, int> > Q;
void spfa(int msk) {
while (!Q.empty()) {
int x, y, xx, yy;
x = Q.front().first;
y = Q.front().second;
Q.pop();
in[x][y] = false;
for (int i = 0; i < 4; i++) {
xx = x + dx[i], yy = y + dy[i];
if (xx >= 1 && xx <= N && yy >= 1 && yy <= M &&
(D[xx][yy][msk] == -1 || D[xx][yy][msk] > D[x][y][msk] + P[xx][yy])) {
D[xx][yy][msk] = D[x][y][msk] + P[xx][yy];
pre[xx][yy][msk] = make_pair(msk, make_pair(x, y));
if (!in[xx][yy]) {
Q.push(make_pair(xx, yy));
in[xx][yy] = true;
}
}
}
}
}
void dfs(int x, int y, int msk) {
if (msk == 0) return;
cov[x][y] = true;
pair<int, pair<int, int> > pi = pre[x][y][msk];
if (pi.first == -1) return;
dfs(pi.second.first, pi.second.second, pi.first);
dfs(pi.second.first, pi.second.second, msk ^ pi.first);
}
int main() {
scanf("%d%d%d", &N, &M, &K);
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++) scanf("%d", &P[i][j]);
for (int i = 0; i < K; i++) scanf("%d%d", &C[i][0], &C[i][1]);
memset(D, -1, sizeof(D));
memset(T, -1, sizeof(T));
memset(pre, -1, sizeof(pre));
memset(cov, false, sizeof(cov));
memset(in, false, sizeof(in));
for (int x = 1; x <= N; x++)
for (int y = 1; y <= M; y++) D[x][y][0] = 0;
for (int i = 0; i < K; i++) {
int x = C[i][0], y = C[i][1];
D[x][y][(1 << i)] = P[x][y];
T[x][y] = i;
}
for (int i = 1; i < (1 << K); i++) {
for (int x = 1; x <= N; x++)
for (int y = 1; y <= M; y++) {
if (T[x][y] != -1 && (i & (1 << T[x][y])) == 0) continue;
for (int j = (i - 1) & i; j; j = (j - 1) & i)
if (D[x][y][j] != -1 && D[x][y][i ^ j] != -1 &&
(D[x][y][i] > D[x][y][j] + D[x][y][i ^ j] - P[x][y] ||
D[x][y][i] == -1)) {
D[x][y][i] = D[x][y][j] + D[x][y][i ^ j] - P[x][y];
pre[x][y][i] = make_pair(j, make_pair(x, y));
}
if (D[x][y][i] != -1) {
in[x][y] = true;
Q.push(make_pair(x, y));
}
}
spfa(i);
}
int ans = -1, xx, yy;
for (int x = 1; x <= N; x++)
for (int y = 1; y <= M; y++)
if (D[x][y][(1 << K) - 1] != -1 &&
(ans == -1 || D[x][y][(1 << K) - 1] < ans)) {
ans = D[x][y][(1 << K) - 1];
xx = x, yy = y;
}
printf("%d\n", ans);
dfs(xx, yy, (1 << K) - 1);
for (int x = 1; x <= N; x++) {
for (int y = 1; y <= M; y++)
if (cov[x][y])
printf("%c", 'X');
else
printf("%c", '.');
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 210;
const int M = 1 << 7;
const int INF = 0x3f3f3f3f;
const int iinf = 1 << 30;
const long long linf = 2e18;
const int MOD = 1000000007;
const double eps = 1e-7;
void print(int x) {
cout << x << endl;
exit(0);
}
void PRINT(string x) {
cout << x << endl;
exit(0);
}
void douout(double x) { printf("%lf\n", x + 0.0000000001); }
int dp[N][M], pre[N][M], vis[N][M];
int hsh[N], maz[N][N];
char g[N][N];
int n, m, k, nn, mm;
int dx[] = {0, 0, -1, 1};
int dy[] = {-1, 1, 0, 0};
struct node {
int x, dis;
};
queue<node> q;
void modify(int x, int dis, int w, int fa) {
if (dp[x][dis] > w) {
dp[x][dis] = w;
pre[x][dis] = fa;
if (!vis[x][dis]) {
q.push((node){x, dis});
vis[x][dis] = 1;
}
}
}
void dfs(int X, int dis) {
int x = X / m, y = X % m;
g[x][y] = 'X';
if (pre[X][dis] == -1) return;
int to = pre[X][dis] / 1000, diss = pre[X][dis] % 1000;
dfs(to, diss);
if (dis - diss) dfs(to, dis - diss);
}
bool check(int x, int y) {
if (x >= 0 && x < n && y >= 0 && y < m) return true;
return false;
}
void getans() {
while (!q.empty()) {
node nw = q.front();
q.pop();
int now = nw.x, x = nw.x / m, y = nw.x % m, dis = nw.dis;
vis[now][dis] = false;
for (int i = (0); i <= (3); i++) {
int tx = x + dx[i], ty = y + dy[i];
if (!check(tx, ty)) continue;
int to = tx * m + ty;
modify(to, dis, dp[now][dis] + maz[tx][ty], now * 1000 + dis);
}
int t = mm - dis - 1;
for (int i = t; i; i = (i - 1) & t) {
modify(now, i | dis, dp[now][i] + dp[now][dis] - maz[x][y],
now * 1000 + dis);
}
}
int ans = iinf, now;
for (int i = (0); i <= (nn - 1); i++)
if (ans > dp[i][mm - 1]) {
ans = dp[i][mm - 1];
now = i;
}
dfs(now, mm - 1);
printf("%d\n", ans);
for (int i = (0); i <= (n - 1); i++) {
for (int j = (0); j <= (m - 1); j++) cout << g[i][j];
cout << endl;
}
}
signed main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = (0); i <= (n - 1); i++) {
for (int j = (0); j <= (m - 1); j++) {
scanf("%d", &maz[i][j]);
g[i][j] = '.';
}
}
nn = n * m;
mm = (1 << k);
memset(hsh, 0, sizeof(hsh));
memset(vis, 0, sizeof(vis));
for (int i = (0); i <= (nn - 1); i++)
for (int j = (0); j <= (mm - 1); j++) dp[i][j] = iinf;
for (int i = (0); i <= (k - 1); i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
int id = a * m + b;
hsh[id] = 1 << i;
modify(id, hsh[id], maz[a][b], -1);
}
getans();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INFTY = 1 << 29;
void build(vector<string>& ans, int bit, int i, vector<vector<int> >& flg,
vector<vector<int> >& path) {
int h = ans.size(), w = ans[0].size();
ans[i / w][i % w] = 'X';
if (flg[bit][i] == 1) {
build(ans, path[bit][i], i, flg, path);
build(ans, bit ^ path[bit][i], i, flg, path);
}
if (flg[bit][i] == 2) {
build(ans, bit, path[bit][i], flg, path);
}
}
int main() {
for (int h, w, c; cin >> h >> w >> c && h | w | c;) {
vector<vector<int> > grid(h, vector<int>(w));
vector<int> ps(c);
for (int i = int(0); i < int(h); i++)
for (int j = int(0); j < int(w); j++) cin >> grid[i][j];
for (int i = int(0); i < int(c); i++) {
int a, b;
cin >> a >> b;
ps[i] = (a - 1) * w + (b - 1);
}
int n = h * w;
vector<vector<int> > dist(n, vector<int>(n, INFTY));
vector<vector<int> > prev(n, vector<int>(n, -1));
for (int i = int(0); i < int(h); i++)
for (int j = int(0); j < int(w); j++) {
dist[i * w + j][i * w + j] = grid[i][j];
int di[] = {-1, 1, 0, 0}, dj[] = {0, 0, -1, 1};
for (int k = int(0); k < int(4); k++) {
int ii = i + di[k], jj = j + dj[k];
if (0 <= ii && ii < h && 0 <= jj && jj < w) {
dist[i * w + j][ii * w + jj] = grid[i][j] + grid[ii][jj];
prev[i * w + j][ii * w + jj] = i * w + j;
}
}
}
for (int k = int(0); k < int(n); k++)
for (int i = int(0); i < int(n); i++)
for (int j = int(0); j < int(n); j++) {
int temp = dist[i][k] + dist[k][j] - dist[k][k];
if (dist[i][j] > temp) {
dist[i][j] = temp;
prev[i][j] = prev[k][j];
}
}
vector<vector<int> > dp(1 << c, vector<int>(n, INFTY));
vector<vector<int> > flg(1 << c, vector<int>(n, 0));
vector<vector<int> > path(1 << c, vector<int>(n, 0));
for (int i = int(0); i < int(c); i++)
for (int j = int(0); j < int(n); j++) {
dp[1 << i][j] = dist[ps[i]][j];
if (j != ps[i]) {
flg[1 << i][j] = 2;
path[1 << i][j] = prev[ps[i]][j];
}
}
for (int bit = int(0); bit < int(1 << c); bit++) {
for (int i = int(0); i < int(n); i++)
for (int j = int(0); j < int(n); j++) {
for (int mask = bit; mask; mask = (mask - 1) & bit) {
int temp =
dp[mask][j] + dp[bit ^ mask][j] + dist[j][i] - dist[j][j] * 2;
if (dp[bit][i] > temp) {
dp[bit][i] = temp;
if (j == i) {
flg[bit][i] = 1;
path[bit][i] = mask;
} else {
flg[bit][i] = 2;
path[bit][i] = prev[j][i];
}
}
}
}
}
int res = INFTY;
for (int i = int(0); i < int(n); i++) res = min(res, dp[(1 << c) - 1][i]);
vector<string> ans(h, string(w, '.'));
for (int i = int(0); i < int(n); i++)
if (dp[(1 << c) - 1][i] == res) {
build(ans, (1 << c) - 1, i, flg, path);
break;
}
cout << res << endl;
for (int i = int(0); i < int(h); i++) cout << ans[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int tag[100][100];
struct node {
int x, y, mask;
node() {}
node(int x, int y, int mask) : x(x), y(y), mask(mask) {}
node L() { return node(x, y - 1, mask | tag[x][y - 1]); }
node R() { return node(x, y + 1, mask | tag[x][y + 1]); }
node U() { return node(x - 1, y, mask | tag[x - 1][y]); }
node D() { return node(x + 1, y, mask | tag[x + 1][y]); }
node operator|(int tmask) { return node(x, y, mask | tmask); }
} last[200][1 << 7];
int f[200][1 << 7];
int a[100][100];
bool inq[200][1 << 7];
int n, m, k;
queue<node> q;
inline bool ckmin(int &a, int b) { return (a > b) && (a = b); }
inline int id(int x, int y) { return x * m + y; }
void update(node now, int val, node pre) {
if (ckmin(f[id(now.x, now.y)][now.mask], val)) {
last[id(now.x, now.y)][now.mask] = pre;
if (!inq[id(now.x, now.y)][now.mask]) {
inq[id(now.x, now.y)][now.mask] = 1;
q.push(now);
}
}
}
void dfs(int x, int y, int mask) {
node pre = last[id(x, y)][mask];
tag[x][y] = 1;
if (!pre.mask) return;
if (pre.x == x && pre.y == y) {
dfs(x, y, pre.mask);
dfs(x, y, mask ^ pre.mask);
} else {
dfs(pre.x, pre.y, pre.mask);
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) scanf("%d", a[i] + j);
memset(f, 127, sizeof(f));
for (int i = 0, x, y; i < k; ++i) {
scanf("%d%d", &x, &y);
--x, --y;
tag[x][y] = 1 << i;
f[id(x, y)][1 << i] = a[x][y];
q.push(node(x, y, 1 << i));
inq[id(x, y)][1 << i] = 1;
}
while (!q.empty()) {
node t = q.front();
q.pop();
if (t.x > 0) update(t.U(), f[id(t.x, t.y)][t.mask] + a[t.x - 1][t.y], t);
if (t.x < n - 1)
update(t.D(), f[id(t.x, t.y)][t.mask] + a[t.x + 1][t.y], t);
if (t.y > 0) update(t.L(), f[id(t.x, t.y)][t.mask] + a[t.x][t.y - 1], t);
if (t.y < m - 1)
update(t.R(), f[id(t.x, t.y)][t.mask] + a[t.x][t.y + 1], t);
int s = ((1 << k) - 1) ^ t.mask;
for (int mask = s; mask; mask = (mask - 1) & s)
if (f[id(t.x, t.y)][mask] < 1e9)
update(t | mask,
f[id(t.x, t.y)][t.mask] + f[id(t.x, t.y)][mask] - a[t.x][t.y],
t);
inq[id(t.x, t.y)][t.mask] = 0;
}
int res = 1e9, mx, my;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (ckmin(res, f[id(i, j)][(1 << k) - 1])) mx = i, my = j;
dfs(mx, my, (1 << k) - 1);
printf("%d\n", res);
for (int i = 0; i < n; puts(""), ++i)
for (int j = 0; j < m; ++j) putchar(tag[i][j] ? 'X' : '.');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 10;
const int inf = (int)1e9 + 9;
const int dx[] = {0, 1, -1, 0};
const int dy[] = {1, 0, 0, -1};
int a[maxn][maxn], id[maxn][maxn], w, h, Num;
int opt[maxn][maxn][1 << 7];
pair<int, int> cache[maxn][maxn][1 << 7];
int type[maxn][maxn][1 << 7];
int imx[20], imy[20];
inline int update(int &a, int value) {
if (value < a) {
a = value;
return 1;
}
return 0;
}
bool inq[maxn][maxn];
vector<string> mat;
void dfs(int x, int y, int stat) {
mat[x - 1][y - 1] = 'X';
if (id[x][y] != -1 && stat == (1 << id[x][y])) {
return;
}
if (type[x][y][stat] == 1) {
dfs(x, y, cache[x][y][stat].first);
dfs(x, y, cache[x][y][stat].second);
} else {
dfs(cache[x][y][stat].first, cache[x][y][stat].second, stat);
}
}
int main() {
cin >> h >> w >> Num;
for (int i = 1; i <= h; ++i) {
for (int j = 1; j <= w; ++j) {
cin >> a[i][j];
}
}
memset(id, -1, sizeof id);
for (int i = 0; i < Num; ++i) {
cin >> imx[i] >> imy[i];
id[imx[i]][imy[i]] = i;
}
for (int i = 1; i <= h; ++i) {
for (int j = 1; j <= w; ++j) {
for (int stat = 0; stat < 1 << Num; ++stat) {
opt[i][j][stat] = inf;
}
if (id[i][j] != -1) {
opt[i][j][1 << id[i][j]] = a[i][j];
}
}
}
for (int stat = 1; stat < 1 << Num; ++stat) {
for (int set = stat; set > 0; set = ((set - 1) & stat)) {
int tmp = stat ^ set;
for (int i = 1; i <= h; ++i) {
for (int j = 1; j <= w; ++j) {
if (update(opt[i][j][stat],
opt[i][j][set] + opt[i][j][tmp] - a[i][j])) {
type[i][j][stat] = 1;
cache[i][j][stat] = make_pair(set, tmp);
}
}
}
}
queue<int> q;
for (int i = 1; i <= h; ++i) {
for (int j = 1; j <= w; ++j) {
inq[i][j] = 0;
if (opt[i][j][stat] < inf) {
q.push(i);
q.push(j);
inq[i][j] = 1;
}
}
}
for (; !q.empty();) {
int x = q.front();
q.pop();
int y = q.front();
q.pop();
inq[x][y] = 0;
for (int k = 0; k < 4; ++k) {
int nx = x + dx[k], ny = y + dy[k];
if (nx >= 1 && ny >= 1 && nx <= h && ny <= w) {
if (update(opt[nx][ny][stat], opt[x][y][stat] + a[nx][ny])) {
type[nx][ny][stat] = 2;
cache[nx][ny][stat] = make_pair(x, y);
if (!inq[nx][ny]) {
inq[nx][ny] = 1;
q.push(nx);
q.push(ny);
}
}
}
}
}
}
int res = inf, x, y;
for (int i = 1; i <= h; ++i) {
for (int j = 1; j <= w; ++j) {
if (update(res, opt[i][j][(1 << Num) - 1])) {
x = i;
y = j;
}
}
}
cout << res << endl;
mat.resize(h, string(w, '.'));
dfs(x, y, (1 << Num) - 1);
for (int i = 0; i < h; ++i) {
cout << mat[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const int MAX_N = 210;
const int MAX_T = 7;
int N;
int cost[MAX_N];
vector<int> ter;
int adj[MAX_N][MAX_N];
int prv_adj[MAX_N][MAX_N];
int opt[1 << MAX_T][MAX_N];
pair<bool, int> prv_opt[1 << MAX_T][MAX_N];
vector<int> sol;
void restore_path(int v, int w) {
if (v == w) return;
int p = prv_adj[v][w];
restore_path(v, p);
sol.push_back(p);
}
void restore(int b, int v) {
if (__builtin_popcount(b) == 1) {
int t = ter[__builtin_ctz(b)];
restore_path(t, v);
} else if (prv_opt[b][v].first) {
int e = prv_opt[b][v].second;
restore(e, v);
restore(b - e, v);
} else {
int w = prv_opt[b][v].second;
restore_path(w, v);
restore(b, w);
}
}
int minimum_steiner_tree() {
int T = ter.size();
if (T == 0) return 0;
for (int i = 0; i < (int)(N); i++) adj[i][i] = 0;
for (int i = 0; i < (int)(N); i++)
for (int j = 0; j < (int)(N); j++) prv_adj[i][j] = i;
for (int k = 0; k < (int)(N); k++)
for (int i = 0; i < (int)(N); i++)
for (int j = 0; j < (int)(N); j++) {
int t = adj[i][k] + cost[k] + adj[k][j];
if (t < adj[i][j]) {
adj[i][j] = t;
prv_adj[i][j] = prv_adj[k][j];
}
}
for (int b = 0; b < (int)(1 << T); b++)
for (int v = 0; v < (int)(N); v++) opt[b][v] = b == 0 ? 0 : INF;
for (int i = 0; i < (int)(T); i++) opt[1 << i][ter[i]] = 0;
for (int b = 1; b < (1 << T); b++) {
for (int p = 0; p < (int)(N); p++) {
int e = b;
do {
int t = opt[e][p] + opt[b - e][p];
if (t < opt[b][p]) {
opt[b][p] = t;
prv_opt[b][p] = make_pair(true, e);
}
e = (e - 1) & b;
} while (e != b);
}
for (int v = 0; v < (int)(N); v++)
for (int w = 0; w < (int)(N); w++) {
int t = opt[b][w] + cost[w] + adj[w][v];
if (t < opt[b][v]) {
opt[b][v] = t;
prv_opt[b][v] = make_pair(false, w);
}
}
}
sol.push_back(ter[0]);
restore((1 << T) - 1, ter[0]);
return cost[ter[0]] + opt[(1 << T) - 1][ter[0]];
}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
int H, W, K;
int fld[110][110];
int vid(int x, int y) { return y * W + x; }
int main() {
for (; 3 == scanf("%d%d%d", &H, &W, &K);) {
for (int y = 0; y < (int)(H); y++)
for (int x = 0; x < (int)(W); x++) {
scanf("%d", &fld[y][x]);
cost[vid(x, y)] = fld[y][x];
}
ter.clear();
for (int k = 0; k < (int)(K); k++) {
int y, x;
scanf("%d%d", &y, &x);
--y;
--x;
ter.push_back(vid(x, y));
}
N = W * H;
for (int i = 0; i < (int)(N); i++)
for (int j = 0; j < (int)(N); j++) adj[i][j] = i == j ? 0 : INF;
for (int y = 0; y < (int)(H); y++)
for (int x = 0; x < (int)(W); x++) {
for (int d = 0; d < (int)(4); d++) {
int tx = x + dx[d];
int ty = y + dy[d];
if (tx < 0 || W <= tx || ty < 0 || H <= ty) continue;
adj[vid(x, y)][vid(tx, ty)] = 0;
}
}
sol.clear();
printf("%d\n", minimum_steiner_tree());
for (int y = 0; y < (int)(H); y++) {
char buf[110] = {};
for (int x = 0; x < (int)(W); x++) {
int c = count((sol).begin(), (sol).end(), vid(x, y));
assert(c < 2);
if (c)
buf[x] = 'X';
else
buf[x] = '.';
}
puts(buf);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 200;
int n;
int m;
int k;
int a[200];
int c[200];
int d[200][200];
int p[200][200];
int dp[128][200];
char ans[200][200];
void drawPath(int u, int v) {
for (; v != u; v = p[u][v]) {
ans[v / m][v % m] = 'X';
}
}
void drawPicture(int mask, int v) {
int minRem = INF;
int u;
for (int i = 0; i < n * m; i++) {
if (dp[mask][v] == dp[mask][i] + d[i][v] && dp[mask][i] < minRem) {
minRem = dp[mask][i];
u = i;
}
}
drawPath(u, v);
if (c[u] >= 0 && (1 << c[u]) == mask) {
ans[u / m][u % m] = 'X';
return;
}
for (int submask = (mask - 1) & mask; submask;
submask = (submask - 1) & mask) {
if (dp[mask][u] == dp[submask][u] + dp[mask ^ submask][u] - a[u]) {
drawPicture(submask, u);
drawPicture(mask ^ submask, u);
return;
}
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i * m + j];
ans[i][j] = '.';
}
}
memset(p, -1, sizeof(p));
for (int i = 0; i < n * m; i++) {
for (int j = 0; j < n * m; j++) {
if (i == j) {
d[i][j] = 0;
continue;
}
if (abs(i / m - j / m) + abs(i % m - j % m) == 1) {
d[i][j] = a[j];
p[i][j] = i;
continue;
}
d[i][j] = INF;
}
}
for (int l = 0; l < n * m; l++) {
for (int i = 0; i < n * m; i++) {
for (int j = 0; j < n * m; j++) {
if (d[i][j] > d[i][l] + d[l][j]) {
d[i][j] = d[i][l] + d[l][j];
p[i][j] = p[l][j];
}
}
}
}
int x;
int y;
memset(c, -1, sizeof(c));
for (int i = 0; i < k; i++) {
cin >> x >> y;
c[--x * m + --y] = i;
}
for (int mask = 1; mask < (1 << k); mask++) {
for (int i = 0; i < n * m; i++) {
if (c[i] >= 0 && (1 << c[i]) == mask)
dp[mask][i] = a[i];
else
dp[mask][i] = INF;
for (int submask = (mask - 1) & mask; submask;
submask = (submask - 1) & mask) {
dp[mask][i] =
min(dp[mask][i], dp[submask][i] + dp[mask ^ submask][i] - a[i]);
}
}
for (int i = 0; i < n * m; i++) {
for (int j = 0; j < n * m; j++) {
dp[mask][i] = min(dp[mask][i], dp[mask][j] + d[j][i]);
}
}
}
int minCost = INF;
int keyPoint;
for (int i = 0; i < n * m; i++) {
if (minCost > dp[(1 << k) - 1][i]) {
minCost = dp[(1 << k) - 1][i];
keyPoint = i;
}
}
drawPicture((1 << k) - 1, keyPoint);
cout << minCost << endl;
for (int i = 0; i < n; i++) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const long long MOD = 1000000007;
const long long INF = 0x3f3f3f3f;
int val[211];
int n, m, k;
int used[111][111];
pair<int, int> pre[211][1 << 8];
int dp[211][1 << 8];
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
vector<int> g[211];
set<int> S[2];
void doit(int p, int sta) {
int u = (p - 1) / m + 1, v = (p - 1) % m + 1;
used[u][v] = 1;
if (pre[p][sta].first == -1) return;
doit(pre[p][sta].first, pre[p][sta].second);
doit(p, sta - pre[p][sta].second);
}
int main() {
int i, j, l, ll, u, v, w, st, pt;
int x, y, p, q;
while (scanf("%d%d%d", &n, &m, &k) != EOF) {
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
u = (i - 1) * m + j;
scanf("%d", &val[u]);
g[u].clear();
if (i > 1) g[u].push_back(u - m);
if (j > 1) g[u].push_back(u - 1);
if (j < m) g[u].push_back(u + 1);
if (i < n) g[u].push_back(u + m);
}
}
for (i = 0; i < 211; i++)
for (j = 0; j < 1 << 8; j++) pre[i][j] = make_pair(-1, -1);
for (u = 1; u <= n; u++) {
for (v = 1; v <= m; v++) {
i = (u - 1) * m + v;
for (j = 0; j < 1 << k; j++) {
dp[i][j] = MOD;
}
}
}
S[0].clear();
S[1].clear();
for (i = 0; i < k; i++) {
scanf("%d%d", &u, &v);
w = (u - 1) * m + v;
dp[w][1 << i] = val[w];
S[0].insert(w);
}
int uu = 0, vv = 1;
for (j = 1; j <= n * m; j++) {
S[vv].clear();
if (S[uu].size() == 0) break;
while (S[uu].size()) {
p = *S[uu].begin();
S[uu].erase(S[uu].begin());
for (i = 0; i < g[p].size(); i++) {
q = g[p][i];
for (l = 0; l < (1 << k); l++) {
if (dp[q][l] > dp[p][l] + val[q]) {
dp[q][l] = dp[p][l] + val[q];
pre[q][l] = make_pair(p, l);
S[vv].insert(q);
}
for (ll = 0; ll < (1 << k); ll++) {
if (ll & l) continue;
if (dp[q][ll | l] > dp[p][l] + dp[q][ll]) {
dp[q][ll | l] = dp[p][l] + dp[q][ll];
pre[q][ll | l] = make_pair(p, l);
S[vv].insert(q);
}
}
}
}
}
swap(uu, vv);
}
int ans = MOD;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) used[i][j] = 0;
for (i = 1; i <= n * m; i++) {
if (ans > dp[i][((1 << k) - 1)]) {
ans = dp[i][((1 << k) - 1)];
p = i;
}
}
doit(p, ((1 << k) - 1));
printf("%d\n", ans);
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (used[i][j])
putchar('X');
else
putchar('.');
}
puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int n, m, k;
int a[220];
int dis[220][220];
int dp[220][220], path[220][220][3];
string s[220];
void floyd() {
memset(dis, 0x3f, sizeof(dis));
for (int x = 0; x < n * m; x++) dis[x][x] = a[x];
for (int x = 0; x < n; x++)
for (int y = 0; y < m; y++) {
for (int d = 0; d < 4; d++) {
int xx = x + dx[d], yy = y + dy[d];
if (xx < 0 || yy < 0 || xx >= n || yy >= m) continue;
dis[x * m + y][xx * m + yy] = a[x * m + y] + a[xx * m + yy];
dis[xx * m + yy][x * m + y] = a[x * m + y] + a[xx * m + yy];
}
}
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++)
if (i != j && dis[i][j] < 0x3f3f3f3f)
for (int x = 0; x < n * m; x++)
if (x != j && x != i && dis[x][i] < 0x3f3f3f3f) {
dis[x][j] = min(dis[x][j], dis[i][j] + dis[x][i] - a[i]);
dis[j][x] = min(dis[j][x], dis[i][j] + dis[x][i] - a[i]);
}
}
vector<int> po;
void cover2(int aa, int b) {
s[aa / m][aa % m] = 'X';
s[b / m][b % m] = 'X';
for (int c = 0; c < n * m; c++)
if (aa != c && b != c && dis[aa][c] + dis[c][b] - a[c] == dis[aa][b]) {
cover2(aa, c);
cover2(c, b);
return;
}
}
void cover(int msk, int pos) {
s[pos / m][pos % m] = 'X';
if (path[pos][msk][0] == 0)
cover(path[pos][msk][1], pos), cover(path[pos][msk][2], pos);
else if (path[pos][msk][0] == 1)
cover(msk, path[pos][msk][1]);
return;
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i * m + j];
po.resize(k);
for (int i = 0; i < n; i++) {
s[i].resize(m);
for (int j = 0; j < m; j++) s[i][j] = '.';
}
memset(dp, 0x3f, sizeof(dp));
for (int i = 0; i < k; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--, y--;
s[x][y] = 'X';
po[i] = (x * m + y);
dp[po[i]][1 << i] = a[po[i]];
path[po[i]][1 << i][0] = 2;
}
for (int i = 0; i < (1 << k); i++) {
for (int pos = 0; pos < n * m; pos++)
for (int ii = i; ii; ii = (ii - 1) & i) {
int tmp = dp[pos][ii] + dp[pos][i ^ ii] - a[pos];
if (tmp < dp[pos][i]) {
dp[pos][i] = tmp;
path[pos][i][0] = 0;
path[pos][i][1] = ii;
path[pos][i][2] = i ^ ii;
}
}
for (int cnt = 0; cnt < n * m + 10; cnt++) {
for (int pos = 0; pos < n * m; pos++) {
int x = (pos / m), y = (pos % m);
for (int d = 0; d < 4; d++) {
int xx = x + dx[d], yy = y + dy[d];
if (xx < 0 || yy < 0 || xx >= n || yy >= m) continue;
int tmp = dp[pos][i] + a[xx * m + yy];
if (tmp < dp[xx * m + yy][i]) {
dp[xx * m + yy][i] = tmp;
path[xx * m + yy][i][0] = 1;
path[xx * m + yy][i][1] = pos;
}
}
}
}
}
int ans = 0x3f3f3f3f, ipos;
for (int i = 0; i < n * m; i++)
if (dp[i][(1 << k) - 1] < ans) {
ans = dp[i][(1 << k) - 1];
ipos = i;
}
cover((1 << k) - 1, ipos);
cout << ans << endl;
for (int i = 0; i < n; i++) {
cout << s[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T& num) {
num = 0;
bool f = true;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = false;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
num = num * 10 + ch - '0';
ch = getchar();
}
num = f ? num : -num;
}
int out[100];
template <class T>
inline void write(T x, char ch) {
if (x == 0) {
putchar('0');
putchar(ch);
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
int num = 0;
while (x) {
out[num++] = (x % 10);
x = x / 10;
}
for (int i = (num - 1); i >= (0); i--) putchar(out[i] + '0');
putchar(ch);
}
const double eps = 1e-8;
bool in[105][105][1000];
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
struct Poi {
int x, y;
} p[10];
int s[105][105];
int dp[105][105][1000], pre[105][105][1000], a[105][105];
int sumsta, n, m, k;
bool vis[105][105];
queue<int> q;
int pack(int x, int y, int st) { return x * 10000000 + y * 10000 + st; }
bool judge(int x, int y) {
if (x <= 0 || y <= 0 || x > n || y > m) return false;
return true;
}
void spfa() {
while (!q.empty()) {
int tmp = q.front();
q.pop();
int x = tmp / 10000000, st = tmp % 10000, y = tmp / 10000 % 1000;
in[x][y][st] = false;
for (int i = (0); i <= (3); i++) {
int xx = x + dx[i], yy = y + dy[i], stt = st | s[xx][yy];
if (!judge(xx, yy)) continue;
if (dp[xx][yy][stt] > dp[x][y][st] + a[xx][yy]) {
dp[xx][yy][stt] = dp[x][y][st] + a[xx][yy];
pre[xx][yy][stt] = tmp;
if (!in[xx][yy][stt] && st == stt) {
in[xx][yy][stt] = true;
q.push(pack(xx, yy, stt));
}
}
}
}
}
void init() {
read(n);
read(m);
read(k);
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++) read(a[i][j]);
sumsta = (1 << k);
for (int i = (0); i <= (sumsta - 1); i++)
for (int x = (1); x <= (n); x++)
for (int y = (1); y <= (m); y++) dp[x][y][i] = pre[x][y][i] = 1070000000;
for (int i = (1); i <= (k); i++) {
int x, y;
read(x);
read(y);
s[x][y] = 1 << (i - 1);
dp[x][y][s[x][y]] = a[x][y];
}
}
void check(int i) {
puts("statu is :");
write(i, '\n');
for (int x = (1); x <= (n); x++) {
for (int y = (1); y <= (m); y++) write(dp[x][y][i], ' ');
puts("");
}
puts("");
}
void getans(int x, int y, int st) {
vis[x][y] = true;
int tmp = pre[x][y][st];
if (tmp == 1070000000) return;
int xx = tmp / 10000000, _st = tmp % 10000, yy = tmp / 10000 % 1000;
getans(xx, yy, _st);
if (x == xx && y == yy) getans(xx, yy, (st - _st) | s[xx][yy]);
}
void work() {
for (int st = (1); st <= (sumsta - 1); st++) {
for (int x = (1); x <= (n); x++)
for (int y = (1); y <= (m); y++) {
for (int i = (st - 1) & st; i; i = (i - 1) & st) {
int d =
dp[x][y][i | s[x][y]] + dp[x][y][(st - i) | s[x][y]] - a[x][y];
if (d < dp[x][y][st]) {
dp[x][y][st] = d;
pre[x][y][st] = pack(x, y, i);
}
}
if (dp[x][y][st] < 1070000000)
q.push(pack(x, y, st)), in[x][y][st] = true;
}
spfa();
}
int ans = 1070000000, xx, yy;
for (int x = (1); x <= (n); x++)
for (int y = (1); y <= (m); y++) {
if (dp[x][y][sumsta - 1] < ans)
ans = min(ans, dp[x][y][sumsta - 1]), xx = x, yy = y;
}
write(ans, '\n');
getans(xx, yy, sumsta - 1);
for (int x = (1); x <= (n); x++) {
for (int y = (1); y <= (m); y++)
if (vis[x][y])
putchar('X');
else
putchar('.');
puts("");
}
}
int main() {
init();
work();
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
const int inf = (1 << 29);
int n, m, k;
cin >> n >> m >> k;
auto h = [&](int i, int j) -> int { return i * m + j; };
auto hr = [&](int x) -> array<int, 2> { return {x / m, x % m}; };
vector<vector<int>> a(n, vector<int>(m, 0));
for (int o = 0; o < n; o++)
for (int i = 0; i < m; i++) cin >> a[o][i];
vector<array<int, 2>> v(k);
for (int i = 0; i < k; i++) {
cin >> v[i][0] >> v[i][1];
v[i][0]--;
v[i][1]--;
}
vector<vector<int>> dp((1 << k), vector<int>(n * m, inf));
vector<vector<bitset<200>>> res((1 << k),
vector<bitset<200>>(n * m, bitset<200>(0)));
for (int o = 0; o < n * m; o++) {
dp[0][o] = a[hr(o)[0]][hr(o)[1]];
res[0][o][o] = 1;
}
vector<vector<int>> d(n * m, vector<int>(n * m, inf));
vector<vector<bitset<200>>> p(n * m,
vector<bitset<200>>(n * m, bitset<200>(0)));
auto in = [&](int i, int j) -> bool {
return (0 <= i && i < n && 0 <= j && j < m);
};
vector<array<int, 2>> z = {{1, 0}, {-1, 0}, {0, -1}, {0, 1}};
for (int o = 0; o < n; o++) {
for (int i = 0; i < m; i++) {
d[h(o, i)][h(o, i)] = a[o][i];
p[h(o, i)][h(o, i)][h(o, i)] = 1;
for (auto [one, two] : z) {
int r = o + one;
int c = i + two;
if (in(r, c) == 0) continue;
d[h(o, i)][h(r, c)] = a[o][i] + a[r][c];
p[h(o, i)][h(r, c)][h(o, i)] = 1;
p[h(o, i)][h(r, c)][h(r, c)] = 1;
}
}
}
for (int j = 0; j < n * m; j++) {
for (int o = 0; o < n * m; o++) {
for (int i = 0; i < n * m; i++) {
if (d[o][j] + d[j][i] - a[hr(j)[0]][hr(j)[1]] < d[o][i]) {
d[o][i] = d[o][j] + d[j][i] - a[hr(j)[0]][hr(j)[1]];
p[o][i] = p[o][j] | p[j][i];
}
}
}
}
for (int i = 0; i < k; i++) {
dp[(1 << i)][h(v[i][0], v[i][1])] = a[v[i][0]][v[i][1]];
res[(1 << i)][h(v[i][0], v[i][1])][h(v[i][0], v[i][1])] = 1;
}
for (int mask = 1; mask < (1 << k); mask++) {
for (int submask = ((mask - 1) & mask); submask > 0;
submask = ((submask - 1) & mask)) {
for (int o = 0; o < n; o++) {
for (int i = 0; i < m; i++) {
if (dp[submask][h(o, i)] + dp[mask ^ submask][h(o, i)] - a[o][i] <
dp[mask][h(o, i)]) {
dp[mask][h(o, i)] =
dp[submask][h(o, i)] + dp[mask ^ submask][h(o, i)] - a[o][i];
res[mask][h(o, i)] =
res[submask][h(o, i)] | res[mask ^ submask][h(o, i)];
}
}
}
}
for (int o = 0; o < n * m; o++) {
for (int i = 0; i < n * m; i++) {
if (o == i) continue;
if (dp[mask][i] + d[o][i] - a[hr(i)[0]][hr(i)[1]] < dp[mask][o]) {
dp[mask][o] = dp[mask][i] + d[o][i] - a[hr(i)[0]][hr(i)[1]];
res[mask][o] = res[mask][i] | p[o][i];
}
}
}
}
int best = inf;
bitset<200> b;
for (int i = 0; i < n * m; i++) {
if (dp[(1 << k) - 1][i] < best) {
best = dp[(1 << k) - 1][i];
b = res[(1 << k) - 1][i];
}
}
cout << best << "\n";
for (int o = 0; o < n; o++) {
for (int i = 0; i < m; i++) cout << ".X"[b[h(o, i)]];
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e2 + 20;
const int maxm = maxn * 4;
const int maxk = 8;
vector<int> adj[maxn], marked;
int n, m, a[maxn], dp[maxn][1 << maxk];
bitset<maxn> ans[maxn][1 << maxk];
int get(int x, int y) { return x * m + y; }
int main() {
memset(dp, 63, sizeof dp);
int k;
cin >> n >> m >> k;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int k = get(i, j);
cin >> a[k];
if (i) adj[k].push_back(get(i - 1, j));
if (i + 1 < n) adj[k].push_back(get(i + 1, j));
if (j) adj[k].push_back(get(i, j - 1));
if (j + 1 < m) adj[k].push_back(get(i, j + 1));
}
for (int i = 0; i < k; i++) {
int x, y;
cin >> x >> y;
x--, y--;
int k1 = get(x, y);
marked.push_back(k1);
dp[k1][1 << i] = a[k1];
ans[k1][1 << i][k1] = 1;
}
int hlp = (1 << k);
for (int mask = 1; mask < hlp; mask++) {
set<pair<int, int> > st;
for (int i = 0; i < n * m; i++) {
for (int submask = (mask - 1) & mask; submask > 0;
submask = (submask - 1) & mask) {
int k = dp[i][submask] + dp[i][mask ^ submask] - a[i];
if (dp[i][mask] > k) {
dp[i][mask] = k;
ans[i][mask] = ans[i][submask] | ans[i][mask ^ submask];
}
}
st.insert({dp[i][mask], i});
}
while (!st.empty()) {
int v = st.begin()->second;
int W = st.begin()->first;
st.erase(st.begin());
if (W != dp[v][mask]) continue;
for (auto u : adj[v])
if (dp[u][mask] > W + a[u]) {
dp[u][mask] = W + a[u];
ans[u][mask] = ans[v][mask];
ans[u][mask][u] = 1;
st.insert({dp[u][mask], u});
}
}
}
int res = dp[marked.back()][hlp - 1];
cout << res << endl;
for (int i = 0; i < n; i++, cout << endl)
for (int j = 0; j < m; j++) {
if (ans[marked.back()][hlp - 1][get(i, j)])
cout << 'X';
else
cout << '.';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int r, c, m, p, q, w[128][200], a[200], u[256], in[200];
pair<int, int> o[128][200];
vector<int> e[200];
char ans[100][105];
void visit(int s, int x) {
ans[x / c][x % c] = 'X';
int t, y;
tie(t, y) = o[s][x];
if (t) visit(t, y);
if (t && t != s) visit(s ^ t, y);
}
int main() {
scanf("%d%d%d", &r, &c, &m);
int mask = (1 << m) - 1, n = r * c;
for (int i = 0; i < r; i++)
for (int j = 0; j < c; j++) {
int x = i * c + j;
scanf("%d", a + x);
if (i) e[x].push_back(x - c);
if (j) e[x].push_back(x - 1);
if (i + 1 < r) e[x].push_back(x + c);
if (j + 1 < c) e[x].push_back(x + 1);
ans[i][j] = '.';
}
memset(w, 63, sizeof(w));
for (int i = 0; i < m; i++) {
scanf("%d%d", &p, &q);
int x = --p * c + --q;
w[1 << i][x] = a[x];
}
for (int x, s = 1; s <= mask; s++) {
for (x = m = 0; x < n; in[u[m++] = x++] = 1)
for (p = (s - 1) & s; p; p = (p - 1) & s) {
int ok = w[p][x] + w[s ^ p][x] - a[x];
if (ok >= w[s][x]) continue;
w[s][x] = ok;
o[s][x] = {p, x};
}
for (int i = 0; i < m; i++) {
in[x = u[i & 255]] = 0;
for (auto y : e[x]) {
int ok = w[s][x] + a[y];
if (ok >= w[s][y]) continue;
w[s][y] = ok;
o[s][y] = {s, x};
if (!in[y]) in[u[m++ & 255] = y] = 1;
}
}
}
int x = min_element(w[mask], w[mask] + n) - w[mask];
visit(mask, x);
printf("%d\n", w[mask][x]);
for (int i = 0; i < r; i++) puts(ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int N, M, K;
int a[100][100];
int xs[7], ys[7];
int dp[1 << 7][100][100];
int pre[1 << 7][100][100][3];
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
bool vis[100][100];
void shortestPath(int mask) {
for (int itr = 0; itr < (int)(N * M + 10); itr++) {
for (int i = 0; i < (int)(N); i++)
for (int j = 0; j < (int)(M); j++)
for (int k = 0; k < (int)(4); k++) {
int x = i + dx[k];
int y = j + dy[k];
if (x < 0 || x >= N) continue;
if (y < 0 || y >= M) continue;
if (dp[mask][i][j] + a[x][y] < dp[mask][x][y]) {
dp[mask][x][y] = dp[mask][i][j] + a[x][y];
pre[mask][x][y][0] = 2;
pre[mask][x][y][1] = i;
pre[mask][x][y][2] = j;
}
}
}
}
void constructPath(int mask, int x, int y) {
vis[x][y] = true;
if (pre[mask][x][y][0] == 1) {
constructPath(pre[mask][x][y][1], x, y);
constructPath(pre[mask][x][y][2], x, y);
} else if (pre[mask][x][y][0] == 2) {
constructPath(mask, pre[mask][x][y][1], pre[mask][x][y][2]);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> N >> M >> K;
for (int i = 0; i < (int)(N); i++)
for (int j = 0; j < (int)(M); j++) cin >> a[i][j];
for (int i = 0; i < (int)(K); i++) cin >> xs[i] >> ys[i], --xs[i], --ys[i];
for (int i = 0; i < (int)(1 << K); i++)
for (int j = 0; j < (int)(N); j++)
for (int k = 0; k < (int)(M); k++) dp[i][j][k] = INF;
for (int i = 0; i < (int)(K); i++) dp[1 << i][xs[i]][ys[i]] = a[xs[i]][ys[i]];
for (int mask = 0; mask < (int)(1 << K); mask++) {
for (int i = 0; i < (int)(N); i++)
for (int j = 0; j < (int)(M); j++) {
for (int submask = mask; submask > 0; submask = (submask - 1) & mask) {
int tmp = dp[submask][i][j] + dp[mask ^ submask][i][j] - a[i][j];
if (tmp < dp[mask][i][j]) {
dp[mask][i][j] = tmp;
pre[mask][i][j][0] = 1;
pre[mask][i][j][1] = submask;
pre[mask][i][j][2] = mask ^ submask;
}
}
}
shortestPath(mask);
}
int ret = INF;
for (int i = 0; i < (int)(N); i++)
for (int j = 0; j < (int)(M); j++) ret = min(ret, dp[(1 << K) - 1][i][j]);
cout << ret << endl;
for (int i = 0; i < (int)(N); i++)
for (int j = 0; j < (int)(M); j++)
if (dp[(1 << K) - 1][i][j] == ret) {
constructPath((1 << K) - 1, i, j);
goto disp;
}
disp:
for (int i = 0; i < (int)(N); i++) {
for (int j = 0; j < (int)(M); j++) {
if (vis[i][j])
cout << "X";
else
cout << ".";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s[110];
const int mod = 1000000007;
int n, m, k;
pair<int, int> pre[1 << 7][220];
int dp[1 << 7][220];
int val[220][220];
int id[220][220];
pair<int, int> p[220];
queue<int> q;
bool inq[1 << 7][220];
void update(int a, int b, int val, int pa, int pb) {
if (dp[a][b] <= val) return;
dp[a][b] = val;
pre[a][b] = make_pair(pa, pb);
if (inq[a][b] == false) {
inq[a][b] = true;
q.push(a);
q.push(b);
}
}
int dir[4][2] = {0, 1, 1, 0, 0, -1, -1, 0};
bool ill(int i, int j) { return i >= 0 && i < n && j >= 0 && j < m; }
char mat[220][220];
bool vst[1 << 7][220];
void dfs(int a, int b) {
if (vst[a][b]) return;
vst[a][b] = true;
int x = p[b].first, y = p[b].second;
mat[x][y] = 'X';
int pa = pre[a][b].first, pb = pre[a][b].second;
if (pb < 0) return;
if (pb == b) {
dfs(pa, pb);
dfs(a - pa, pb);
} else {
dfs(pa, pb);
}
}
int main() {
while (scanf("%d %d %d", &n, &m, &k) != EOF) {
int cnt = 0;
for (int i = (0); i < (n); i++)
for (int j = (0); j < (m); j++) {
scanf("%d", val[i] + j);
id[i][j] = cnt;
p[cnt++] = make_pair(i, j);
}
memset(dp, 0x3f, sizeof(dp));
memset(inq, false, sizeof(inq));
for (int i = (0); i < (k); i++) {
int x, y;
scanf("%d %d", &x, &y);
x--;
y--;
update(1 << i, id[x][y], val[x][y], -1, -1);
}
while (!q.empty()) {
int a = q.front();
q.pop();
int b = q.front();
q.pop();
inq[a][b] = false;
for (int in = (0); in < (4); in++) {
int tx = p[b].first + dir[in][0];
int ty = p[b].second + dir[in][1];
if (ill(tx, ty) == false) continue;
update(a, id[tx][ty], dp[a][b] + val[tx][ty], a, b);
}
int tt = (1 << k) - 1 - a;
for (int s = tt; s; s = (s - 1) & tt) {
update(a | s, b, dp[a][b] + dp[s][b] - val[p[b].first][p[b].second], a,
b);
}
}
int mi = 1 << 30;
int b;
for (int j = (0); j < (cnt); j++) {
if (dp[(1 << k) - 1][j] < mi) {
mi = dp[(1 << k) - 1][j];
b = j;
}
}
printf("%d\n", mi);
memset(vst, false, sizeof(vst));
memset(mat, '.', sizeof(mat));
dfs((1 << k) - 1, b);
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) putchar(mat[i][j]);
puts("");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e7;
int garden[111][111];
int dp[111][111][1 << 7];
int way[111][111][1 << 7][3];
int N, M, K;
bool path[111][111];
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
void updateWay(int mask) {
for (int t = 0; t <= N * M; t++)
for (int x = 1; x <= N; x++)
for (int y = 1; y <= M; y++)
for (int d = 0; d < 4; d++) {
int nx = x + dx[d], ny = y + dy[d];
if (nx < 1 || nx > N || ny < 1 || ny > M) continue;
if (dp[nx][ny][mask] > dp[x][y][mask] + garden[nx][ny]) {
dp[nx][ny][mask] = dp[x][y][mask] + garden[nx][ny];
way[nx][ny][mask][0] = 0;
way[nx][ny][mask][1] = x;
way[nx][ny][mask][2] = y;
}
}
}
void genPath(int x, int y, int mask) {
path[x][y] = true;
if (way[x][y][mask][0] == 0)
genPath(way[x][y][mask][1], way[x][y][mask][2], mask);
else if (way[x][y][mask][0] == 1) {
genPath(x, y, way[x][y][mask][1]);
genPath(x, y, way[x][y][mask][2]);
}
}
int main() {
cin >> N >> M >> K;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++) cin >> garden[i][j];
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++)
for (int k = 0; k < 1 << K; k++) dp[i][j][k] = oo, way[i][j][k][0] = -1;
for (int i = 0; i < K; i++) {
int x, y;
cin >> x >> y;
dp[x][y][1 << i] = garden[x][y];
way[x][y][1 << i][0] = -1;
}
for (int mask = 1; mask < (1 << K); mask++) {
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++)
for (int smask = (mask - 1) & mask; smask; smask = (smask - 1) & mask) {
int com = dp[i][j][smask] + dp[i][j][mask ^ smask] - garden[i][j];
if (dp[i][j][mask] > com) {
dp[i][j][mask] = com;
way[i][j][mask][0] = 1;
way[i][j][mask][1] = smask;
way[i][j][mask][2] = mask ^ smask;
}
}
updateWay(mask);
}
int ans = oo;
int bx, by;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++)
if (ans > dp[i][j][(1 << K) - 1])
ans = dp[i][j][(1 << K) - 1], bx = i, by = j;
genPath(bx, by, (1 << K) - 1);
cout << ans << endl;
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) cout << (path[i][j] ? 'X' : '.');
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
int pq[1 + ((1 << 7) * 200)], iq[((1 << 7) * 200)], dd[((1 << 7) * 200)], cnt;
int less(int u, int v) { return dd[u] < dd[v]; }
int i2(int i) {
return (i *= 2) > cnt ? 0 : i < cnt && less(pq[i + 1], pq[i]) ? i + 1 : i;
}
void pq_up(int u) {
int i, j, v;
for (i = iq[u]; (j = i / 2) && less(u, v = pq[j]); i = j) pq[iq[v] = i] = v;
pq[iq[u] = i] = u;
}
void pq_dn(int u) {
int i, j, v;
for (i = iq[u]; (j = i2(i)) && less(v = pq[j], u); i = j) pq[iq[v] = i] = v;
pq[iq[u] = i] = u;
}
void pq_add_last(int u) { pq[iq[u] = ++cnt] = u; }
int pq_remove_first() {
int u = pq[1], v = pq[cnt--];
iq[v] = 1;
pq_dn(v);
return u;
}
void pq_build() {
int i;
for (i = cnt / 2; i > 0; i--) pq_dn(pq[i]);
}
int n, m;
int encode(int b, int i, int j) { return (b * n + i) * m + j; }
int bb[1 << 7][100][100], hh[1 << 7][100][100];
int di[] = {-1, 1, 0, 0};
int dj[] = {0, 0, -1, 1};
void update(int b, int i, int j, int a) {
int h, ab = a | b;
int c = encode(ab, i, j);
int d = dd[encode(b, i, j)];
for (h = 0; h < 4; h++) {
int i_ = i + di[h], j_ = j + dj[h], c_, d2;
if (i_ < 0 || i_ >= n || j_ < 0 || j_ >= m) continue;
c_ = encode(ab, i_, j_);
d2 = d + dd[encode(a, i_, j_)];
if (dd[c_] > d2) {
if (dd[c_] == 0x3f3f3f3f) pq_add_last(c_);
dd[c_] = d2, bb[ab][i_][j_] = b, hh[ab][i_][j_] = h ^ 1;
pq_up(c_);
}
if (dd[c] > d2) {
if (dd[c] == 0x3f3f3f3f) pq_add_last(c);
dd[c] = d2, bb[ab][i][j] = a, hh[ab][i][j] = h;
pq_up(c);
}
}
}
char map[100][100 + 1];
void mark(int b, int i, int j) {
int a, h;
if (hh[b][i][j] == -1) {
map[i][j] = 'X';
return;
}
a = bb[b][i][j], h = hh[b][i][j];
mark(a, i + di[h], j + dj[h]);
mark(b ^ a, i, j);
}
int main() {
static int aa[100][100];
int k, all, nm, n_, h, i, j;
scanf("%d%d%d", &n, &m, &k);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
scanf("%d", &aa[i][j]);
map[i][j] = '.';
}
all = (1 << k) - 1;
nm = n * m, n_ = (1 << k) * nm;
memset(dd, 0x3f, n_ * sizeof *dd);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
int b = 0, c = encode(b, i, j);
dd[c] = aa[i][j], hh[b][i][j] = -1;
pq_add_last(c);
}
for (h = 0; h < k; h++) {
int b, c;
scanf("%d%d", &i, &j), i--, j--;
b = 1 << h, c = encode(b, i, j);
dd[c] = aa[i][j], hh[b][i][j] = -1;
pq_add_last(c);
}
pq_build();
while (cnt) {
int c = pq_remove_first(), b, b_, a;
b = c / nm, i = c % nm / m, j = c % m;
if (b == all) {
printf("%d\n", dd[c]);
mark(b, i, j);
for (i = 0; i < n; i++) printf("%s\n", map[i]);
return 0;
}
a = 0, b_ = b ^ all;
do update(b, i, j, a);
while ((a = a - b_ & b_));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, s, M[128][128];
vector<vector<int> > dist[128][128];
vector<vector<pair<int, int> > > paidist[128][128];
short int terminal[128][128];
pair<int, int> S[12];
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int PD[(1 << 7)][101][101][2];
bool split[(1 << 7)][101][101][2];
pair<pair<int, int>, pair<int, int> > pai[(1 << 7)][101][101][2];
char R[128][128];
inline void imprime() {
for (int i = 0; i < n; i++) printf("%s\n", R[i]);
}
void pinta_caminho(int i1, int j1, int i2, int j2) {
if (i1 == i2 and j1 == j2) {
R[i1][j1] = 'X';
return;
}
pair<int, int> p = paidist[i1][j1][i2][j2];
if (p.first == i1 and p.second == j1) {
R[i1][j1] = 'X';
R[i2][j2] = 'X';
return;
}
pinta_caminho(i1, j1, p.first, p.second);
pinta_caminho(p.first, p.second, i2, j2);
}
void pinta_arvore(int bm, int i, int j, int pfolha) {
if (bm == 0) {
R[i][j] = 'X';
return;
}
if (__builtin_popcount(bm) == 1) {
int t = __builtin_ctz(bm);
pinta_caminho(S[t].first, S[t].second, i, j);
return;
}
pair<pair<int, int>, pair<int, int> > u = pai[bm][i][j][pfolha];
int nbm = u.first.first, npfolha = u.first.second;
int ni = u.second.first, nj = u.second.second;
if (split[bm][i][j][pfolha]) {
pinta_arvore(nbm, i, j, npfolha);
pinta_arvore(bm ^ nbm, i, j, npfolha);
return;
}
pinta_caminho(i, j, ni, nj);
pinta_arvore(nbm, ni, nj, npfolha);
}
int calc(int bm, int i, int j, int pfolha) {
if (bm == 0) return M[i][j];
int &pd = PD[bm][i][j][pfolha];
pair<pair<int, int>, pair<int, int> > &papai = pai[bm][i][j][pfolha];
bool &sp = split[bm][i][j][pfolha];
if (pd != -1) return pd;
if (__builtin_popcount(bm) == 1) {
int t = __builtin_ctz(bm);
return pd = dist[S[t].first][S[t].second][i][j];
}
int best = 0x3f3f3f3f;
int x = (bm - 1) & bm;
while (x) {
int t1 = calc(x, i, j, 1);
int t2 = calc(bm ^ x, i, j, 1);
int opc = t1 + t2 - M[i][j];
if (opc < best) {
best = opc;
papai = pair<pair<int, int>, pair<int, int> >(pair<int, int>(x, 1),
pair<int, int>(i, j));
sp = true;
}
x = (x - 1) & bm;
}
if (pfolha) {
for (int k = 0; k < s; k++)
if (bm & (1 << k)) {
int opc = dist[i][j][S[k].first][S[k].second] +
calc(bm ^ (1 << k), S[k].first, S[k].second, 1) -
M[S[k].first][S[k].second];
if (opc < best) {
best = opc;
sp = false;
papai = pair<pair<int, int>, pair<int, int> >(
pair<int, int>(bm ^ (1 << k), 1),
pair<int, int>(S[k].first, S[k].second));
}
}
for (int k = 0; k < n; k++)
for (int l = 0; l < m; l++)
if ((k != i or l != j) and terminal[k][l] < 0) {
int opc = dist[i][j][k][l] + calc(bm, k, l, 0) - M[k][l];
if (opc < best) {
best = opc;
sp = false;
papai = pair<pair<int, int>, pair<int, int> >(pair<int, int>(bm, 0),
pair<int, int>(k, l));
}
}
}
return pd = best;
}
int main() {
scanf("%d %d %d", &n, &m, &s);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
R[i][j] = '.';
dist[i][j].resize(n);
paidist[i][j].resize(n);
for (int k = 0; k < n; k++) {
dist[i][j][k].resize(m);
paidist[i][j][k].resize(m);
for (int l = 0; l < m; l++) dist[i][j][k][l] = 0x3f3f3f3f;
}
}
R[i][m] = '\0';
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
scanf("%d", &M[i][j]);
dist[i][j][i][j] = M[i][j];
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int k = 0; k < 4; k++) {
int ni = i + dx[k];
int nj = j + dy[k];
if (!(0 <= ni and ni < n and 0 <= nj and nj < m)) continue;
dist[i][j][ni][nj] = M[i][j] + M[ni][nj];
paidist[i][j][ni][nj] = pair<int, int>(i, j);
}
for (int k1 = 0; k1 < n; k1++)
for (int k2 = 0; k2 < m; k2++)
for (int i1 = 0; i1 < n; i1++)
for (int i2 = 0; i2 < m; i2++)
for (int j1 = 0; j1 < n; j1++)
for (int j2 = 0; j2 < m; j2++) {
int opc = dist[i1][i2][k1][k2] + dist[k1][k2][j1][j2] - M[k1][k2];
if (opc < dist[i1][i2][j1][j2]) {
dist[i1][i2][j1][j2] = opc;
paidist[i1][i2][j1][j2] = pair<int, int>(k1, k2);
}
}
memset(terminal, 0xff, sizeof(terminal));
for (int i = 0; i < s; i++) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
terminal[a][b] = i;
S[i] = pair<int, int>(a, b);
}
if (s == 1) {
printf("%d\n", M[S[0].first][S[0].second]);
R[S[0].first][S[0].second] = 'X';
imprime();
return 0;
}
if (s == 2) {
printf("%d\n", dist[S[0].first][S[0].second][S[1].first][S[1].second]);
pinta_caminho(S[0].first, S[0].second, S[1].first, S[1].second);
imprime();
return 0;
}
memset(PD, 0xff, sizeof(PD));
int resp = calc((1 << s) - 1 - 1, S[0].first, S[0].second, 1);
int bm = (1 << s) - 1 - 1, i = S[0].first, j = S[0].second, pf = 1;
pinta_arvore(bm, i, j, pf);
printf("%d\n", resp);
imprime();
int tot = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (R[i][j] == 'X') tot += M[i][j];
if (resp != tot) printf("PAU! resp = %d, cert = %d\n", resp, tot);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 29;
const int MAX = 200 + 10;
int dp[MAX][1 << 7], pre[MAX][1 << 7];
int n, m, k, nn, mm;
int hash1[MAX];
int maz[MAX][MAX];
char g[MAX][MAX];
bool visit[MAX][1 << 7];
int dx[] = {0, 0, -1, 1};
int dy[] = {-1, 1, 0, 0};
struct Node {
int u, st;
Node(int _u, int _st) { u = _u, st = _st; }
};
queue<Node> que;
bool check(int x, int y) {
if (x >= 0 && x < n && y >= 0 && y < m) return true;
return false;
}
void update(int u, int st, int w, int fa) {
if (dp[u][st] > w) {
dp[u][st] = w;
pre[u][st] = fa;
if (!visit[u][st]) {
que.push(Node(u, st));
visit[u][st] = true;
}
}
}
void dfs(int u, int st) {
int x = u / m, y = u % m;
g[x][y] = 'X';
if (pre[u][st] == -1)
return;
else {
int v = pre[u][st] / 1000, stt = pre[u][st] % 1000;
dfs(v, stt);
if (stt - st) dfs(v, st - stt);
}
}
void solve() {
while (!que.empty()) {
Node now = que.front();
que.pop();
int u = now.u, x = now.u / m, y = now.u % m, st = now.st;
visit[u][st] = false;
for (int i = 0; i < 4; i++) {
int xx = x + dx[i], yy = y + dy[i];
if (!check(xx, yy)) continue;
int v = xx * m + yy;
update(v, st, dp[u][st] + maz[xx][yy], u * 1000 + st);
}
int t = mm - 1 - st;
for (int i = t; i; i = (i - 1) & t) {
update(u, i | st, dp[u][i] + dp[u][st] - maz[x][y], u * 1000 + st);
}
}
int ans = inf, u;
for (int i = 0; i < nn; i++) {
if (ans > dp[i][mm - 1]) {
ans = dp[i][mm - 1];
u = i;
}
}
dfs(u, mm - 1);
cout << ans << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << g[i][j];
cout << endl;
}
}
int main() {
while (cin >> n >> m >> k) {
while (!que.empty()) que.pop();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> maz[i][j];
g[i][j] = '.';
}
}
nn = n * m, mm = 1 << k;
memset(hash1, 0, sizeof(hash1));
memset(visit, false, sizeof(visit));
for (int i = 0; i < nn; i++)
for (int j = 0; j < mm; j++) dp[i][j] = inf;
for (int i = 0, a, b; i < k; i++) {
cin >> a >> b;
a--, b--;
int u = a * m + b;
hash1[u] = 1 << i;
update(u, hash1[u], maz[a][b], -1);
}
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 199406060;
int n, m;
int f[1 << 7][203];
int a[203][203];
int p[20], x[20], y[20], V, pre[1 << 7][203][2], val[203];
int id[202][202];
int q[400000];
bool need[202];
int d[7];
bool xl(int i1, int i2) {
pair<int, int> s, e;
s.first = (i1 - 1) / m + 1;
s.second = (i1 - 1) % m + 1;
e.first = (i2 - 1) / m + 1;
e.second = (i2 - 1) % m + 1;
return (abs(s.first - e.first) + abs(s.second - e.second)) == 1;
}
int get(int x) { return x % 300; }
bool can(int i, int qq) {
if (qq == 0) return i % m != 1 && m != 1;
if (qq == 1) return i % m != 0;
if (qq == 2) return i + m <= V;
if (qq == 3) return i - m >= 1;
}
int bm(int i, int j) { return i * 300 + j; }
int main() {
int i, j, k, b, c, K, qq, tmp;
bool flag;
int all;
scanf("%d%d%d", &n, &m, &K);
all = (1 << K) - 1;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
id[i][j] = (i - 1) * m + j;
val[id[i][j]] = a[i][j];
}
V = id[n][m];
d[0] = -1;
d[1] = 1;
d[2] = m;
d[3] = -m;
for (i = 0; i <= all; i++)
for (j = 1; j <= V; j++) f[i][j] = inf;
for (i = 0; i < K; i++)
scanf("%d%d", &x[i], &y[i]), p[i] = id[x[i]][y[i]],
f[1 << i][p[i]] = a[x[i]][y[i]];
for (i = 1; i <= all; i++) {
for (j = 1; j < i; j++)
if ((i | j) == i) {
for (k = 1; k <= V; k++)
for (qq = 0; qq < 4; qq++) {
if (!can(k, qq)) continue;
tmp = k + d[qq];
if (f[i][k] > f[i - j][k] + f[j][tmp])
f[i][k] = f[i - j][k] + f[j][tmp], pre[i][k][0] = bm(i - j, k),
pre[i][k][1] = bm(j, tmp);
}
}
flag = true;
while (flag) {
flag = false;
for (j = 1; j <= V; j++) {
for (qq = 0; qq < 4; qq++)
if (can(j, qq) && f[i][j] + val[j + d[qq]] < f[i][j + d[qq]]) {
f[i][j + d[qq]] = f[i][j] + val[j + d[qq]], flag = true,
pre[i][j + d[qq]][0] = bm(i, j), pre[i][j + d[qq]][1] = 0;
}
}
}
}
int ans = inf, last;
for (i = 1; i <= V; i++)
if (ans > f[all][i]) last = bm(all, i), ans = f[all][i];
printf("%d\n", ans);
int h = 1, tail = 1, s;
q[h] = last;
while (h <= tail) {
s = q[h++];
need[get(s)] = true;
if (pre[s / 300][s % 300][0]) q[++tail] = pre[s / 300][s % 300][0];
if (pre[s / 300][s % 300][1]) q[++tail] = pre[s / 300][s % 300][1];
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (need[id[i][j]])
printf("X");
else
printf(".");
}
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class P, class Q>
inline void smin(P &a, Q b) {
if (b < a) a = b;
}
template <class P, class Q>
inline void smax(P &a, Q b) {
if (a < b) a = b;
}
const int maxn = 200 + 10;
const int inf = 1 << 28;
int n, m, k;
int a[maxn];
int d[maxn][maxn];
int pos[7];
int dp[1 << 7][maxn];
string mat[maxn];
void solve(int mask, int id) {
int goal = dp[mask][id];
mat[id / m][id % m] = 'X';
if (a[id] == goal) return;
if (id % m && goal == dp[mask][id - 1] + a[id]) {
solve(mask, id - 1);
return;
}
if (id % m + 1 < m && goal == dp[mask][id + 1] + a[id]) {
solve(mask, id + 1);
return;
}
if (id - m >= 0 && goal == dp[mask][id - m] + a[id]) {
solve(mask, id - m);
return;
}
if (id + m < n && goal == dp[mask][id + m] + a[id]) {
solve(mask, id + m);
return;
}
for (int sub = (mask - 1) & mask; sub; sub = (sub - 1) & mask)
if (goal == dp[mask ^ sub][id] + dp[sub][id] - a[id]) {
solve(mask ^ sub, id);
solve(sub, id);
continue;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k;
n *= m;
for (int i = 0, _n = (int)(n); i < _n; i++) cin >> a[i];
for (int i = 0, _n = (int)(k); i < _n; i++) {
int x, y;
cin >> x >> y;
x--, y--;
pos[i] = x * m + y;
}
for (int i = 0, _n = (int)(n); i < _n; i++)
for (int j = 0, _n = (int)(n); j < _n; j++) {
if (i == j)
d[i][j] = 0;
else if (i / m == j / m && abs(i - j) == 1)
d[i][j] = a[j];
else if (i % m == j % m && abs(i - j) == m)
d[i][j] = a[j];
else
d[i][j] = inf;
}
for (int k = 0, _n = (int)(n); k < _n; k++)
for (int i = 0, _n = (int)(n); i < _n; i++)
for (int j = 0, _n = (int)(n); j < _n; j++)
smin(d[i][j], d[i][k] + d[k][j]);
for (int mask = 0, _n = (int)(1 << k); mask < _n; mask++)
for (int i = 0, _n = (int)(n); i < _n; i++) dp[mask][i] = inf;
for (int mask = (int)(1), _n = (int)(1 << k); mask < _n; mask++) {
if ((mask & (mask - 1)) == 0) {
for (int i = 0, _n = (int)(n); i < _n; i++) {
int p = pos[__builtin_ctz(mask)];
dp[mask][i] = d[p][i] + a[p];
}
continue;
}
for (int i = 0, _n = (int)(n); i < _n; i++)
for (int sub = (mask - 1) & mask; sub; sub = (sub - 1) & mask)
smin(dp[mask][i], dp[mask ^ sub][i] + dp[sub][i] - a[i]);
for (int i = 0, _n = (int)(n); i < _n; i++)
for (int j = 0, _n = (int)(n); j < _n; j++)
smin(dp[mask][i], dp[mask][j] + d[j][i]);
}
int fmask = (1 << k) - 1;
int ans = inf;
for (int i = 0, _n = (int)(n); i < _n; i++) smin(ans, dp[fmask][i]);
cout << ans << endl;
for (int i = 0, _n = (int)(n / m); i < _n; i++) mat[i] = string(m, '.');
solve(fmask, min_element(dp[fmask], dp[fmask] + n) - dp[fmask]);
for (int i = 0, _n = (int)(n / m); i < _n; i++) cout << mat[i] << endl;
{ return 0; }
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[205][1 << 7], f[205][1 << 7][2], q[205], qr, qw;
bool v[205];
void trace(int z, int s, bool sol[]) {
if (f[z][s][0] == -1)
sol[z] = true;
else if (f[z][s][0] == z)
trace(f[z][s][0], s ^ f[z][s][1], sol), trace(f[z][s][0], f[z][s][1], sol);
else
sol[z] = true, trace(f[z][s][0], f[z][s][1], sol);
}
int SMST(int n, int w[], int h[], int t[][2], int l[], int k, bool sol[]) {
int state = 1 << k;
for (int i = 0; i < n; ++i)
for (int j = 0; j < state; ++j) dp[i][j] = (j == 0 ? 0 : 1000000000);
for (int i = 0; i < k; ++i) {
dp[l[i]][1 << i] = w[l[i]];
f[l[i]][1 << i][0] = f[l[i]][1 << i][1] = -1;
}
qr = qw = 0;
memset(v, true, sizeof(v));
for (int i = 0; i < state; ++i) {
for (int j = 0; j < n; ++j) {
for (int o = (i - 1) & i; o > 0; o = (o - 1) & i) {
int tmp = dp[j][i ^ o] + dp[j][o] - w[j];
if (tmp < dp[j][i]) {
dp[j][i] = tmp;
f[j][i][0] = j;
f[j][i][1] = o;
}
}
if (dp[j][i] != 1000000000) {
q[qw++] = j;
if (qw == 205) qw = 0;
v[j] = false;
}
}
while (qr != qw) {
int x = q[qr++];
if (qr == 205) qr = 0;
v[x] = true;
for (int j = h[x]; j != -1; j = t[j][1]) {
int y = t[j][0];
if (dp[x][i] + w[y] < dp[y][i]) {
dp[y][i] = dp[x][i] + w[y];
f[y][i][0] = x;
f[y][i][1] = i;
if (v[y]) {
q[qw++] = y;
if (qw == 205) qw = 0;
v[y] = false;
}
}
}
}
}
int mi = 1000000000, mii = -1;
for (int i = 0; i < n; ++i)
if (dp[i][state - 1] < mi) mi = dp[i][state - 1], mii = i;
for (int i = 0; i < n; ++i) sol[i] = false;
trace(mii, state - 1, sol);
return mi;
}
int m, n, k, w[205], h[205], t[1000][2], tw, l[7];
void adde(int x, int y) {
t[tw][0] = y;
t[tw][1] = h[x];
h[x] = tw++;
}
int main() {
scanf("%d%d%d", &m, &n, &k);
memset(h, -1, sizeof(h));
tw = 0;
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
scanf("%d", &w[i * n + j]);
if (i) adde((i - 1) * n + j, i * n + j), adde(i * n + j, (i - 1) * n + j);
if (j) adde(i * n + (j - 1), i * n + j), adde(i * n + j, i * n + (j - 1));
}
}
for (int i = 0; i < k; ++i) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
l[i] = x * n + y;
}
bool sol[205];
int ans = SMST(m * n, w, h, t, l, k, sol);
printf("%d\n", ans);
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
printf("%c", sol[i * n + j] ? 'X' : '.');
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
const int M = 300;
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
int n, m, K;
int dp[N][M], pre[N][M];
int mat[N], vis[N], st[N];
bool in[N][M];
queue<int> que;
void spfa() {
while (que.size()) {
int top = que.front();
que.pop();
int x = top / 1000 / m, y = (top / 1000) % m, s = top % 1000;
in[x * m + y][s] = 0;
for (int i = 0; i < 4; i++) {
int tx = x + dx[i], ty = y + dy[i];
if (tx >= n || tx < 0 || ty >= m || ty < 0) continue;
int ts = s | st[tx * m + ty];
if (dp[tx * m + ty][ts] > dp[x * m + y][s] + mat[tx * m + ty]) {
dp[tx * m + ty][ts] = dp[x * m + y][s] + mat[tx * m + ty];
pre[tx * m + ty][ts] = top;
if (in[tx * m + ty][ts] == 0 && s == ts) {
in[tx * m + ty][ts] = 1;
que.push((tx * m + ty) * 1000 + ts);
}
}
}
}
}
void getans(int x, int y, int mask) {
vis[x * m + y] = 1;
int tmp = pre[x * m + y][mask];
if (tmp == 0) return;
int tx = tmp / 1000 / m, ty = (tmp / 1000) % m, s1 = tmp % 1000;
getans(tx, ty, s1);
if (tx == x && ty == y) getans(tx, ty, ((mask - s1) | st[x * m + y]));
}
int main() {
scanf("%d%d%d", &n, &m, &K);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &mat[i * m + j]);
memset(dp, 63, sizeof(dp));
int a, b;
for (int i = 0; i < K; i++) {
scanf("%d%d", &a, &b);
a--;
b--;
st[a * m + b] = (1 << i);
dp[a * m + b][(1 << i)] = mat[a * m + b];
}
int mask = (1 << K) - 1;
for (int s = 1; s <= mask; s++) {
for (int i = 0; i < n * m; i++) {
if (st[i] && !(st[i] & s)) continue;
for (int p = (s - 1) & s; p; p = (p - 1) & s) {
int s1 = p | st[i], s2 = (s - p) | st[i];
int d = dp[i][s1] + dp[i][s2] - mat[i];
if (d < dp[i][s]) {
pre[i][s] = i * 1000 + s1;
dp[i][s] = d;
}
}
if (dp[i][s] != 1061109567) in[i][s] = 1, que.push(i * 1000 + s);
}
spfa();
}
printf("%d\n", dp[a * m + b][mask]);
getans(a, b, mask);
for (int i = 0; i < n; i++, puts(""))
for (int j = 0; j < m; j++) {
if (vis[i * m + j])
putchar('X');
else
putchar('.');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int g[100][100], h[100][100];
int imp[7][2];
int d[200][200];
int f[1 << 7][200], p[1 << 7][200][4];
void update(int con, int v, int x, int con2, int v2, int con3 = -1,
int v3 = -1) {
if (x < f[con][v]) {
f[con][v] = x;
p[con][v][0] = con2;
p[con][v][1] = v2;
p[con][v][2] = con3;
p[con][v][3] = v3;
}
}
int r[100][100];
void getpath(int i, int j) {
int yi = i / m, xi = i % m, yj = j / m, xj = j % m;
int dist = abs(yi - yj) + abs(xi - xj);
if (dist <= 1) {
r[yi][xi] = 1;
r[yj][xj] = 1;
} else {
for (int v = 0; v < n * m; v++)
if (v != i && v != j) {
int yv = v / m, xv = v % m;
if (d[i][v] + d[v][j] - g[yv][xv] == d[i][j]) {
getpath(i, v);
getpath(v, j);
break;
}
}
}
}
void reconstruct(int con, int v) {
int nodes = 0, ni = -1;
for (int i = 0; i < k; i++)
if (con & (1 << i)) {
nodes++;
ni = i;
}
if (nodes == 1) {
int y = imp[ni][0], x = imp[ni][1];
int id = y * m + x;
getpath(v, id);
} else {
int con1 = p[con][v][0], v1 = p[con][v][1];
int con2 = p[con][v][2], v2 = p[con][v][3];
if (con2 != -1) {
reconstruct(con1, v1);
reconstruct(con2, v2);
} else {
getpath(v, v1);
reconstruct(con1, v1);
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &g[i][j]);
for (int i = 0; i < k; i++) {
scanf("%d %d", &imp[i][0], &imp[i][1]);
imp[i][0]--;
imp[i][1]--;
h[imp[i][0]][imp[i][1]] = i + 1;
}
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++) {
int yi = i / m, xi = i % m, yj = j / m, xj = j % m;
d[i][j] = 999999999;
int dist = abs(yi - yj) + abs(xi - xj);
if (dist <= 1) d[i][j] = g[yi][xi] + g[yj][xj];
}
for (int a = 0; a < n * m; a++) {
int r = a / m, c = a % m;
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++) {
d[i][j] = min(d[i][j], d[i][a] + d[a][j] - g[r][c]);
;
}
}
for (int con = 1; con < (1 << k); con++) {
int nodes = 0, ni = -1;
for (int i = 0; i < k; i++)
if (con & (1 << i)) {
nodes++;
ni = i;
}
for (int v = 0; v < n * m; v++) {
int &ff = f[con][v];
ff = 999999999;
if (nodes == 1) {
int y = imp[ni][0], x = imp[ni][1];
int id = y * m + x;
ff = d[v][id];
}
}
for (int v = 0; v < n * m; v++) {
int vi = v / m, vj = v % m;
int &ff = f[con][v];
for (int sub = (con - 1) & con; sub > 0; sub = (sub - 1) & con) {
update(con, v, f[sub][v] + f[con ^ sub][v] - g[vi][vj], sub, v,
con ^ sub, v);
}
}
for (int v = 0; v < n * m; v++) {
int &ff = f[con][v];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int u = i * m + j;
int val = f[con][u] + d[v][u] - g[i][j] -
((con & (1 << (h[i][j] - 1))) ? g[i][j] : 0);
update(con, v, val, con, u);
}
}
}
int y0 = imp[0][0], x0 = imp[0][1];
int id0 = y0 * m + x0;
printf("%d\n", f[(1 << k) - 1][id0] - g[y0][x0]);
reconstruct((1 << k) - 1, id0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (r[i][j] == 1)
printf("X");
else
printf(".");
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
const int mod = 1000000007;
int modpow(int x, int y, int md) {
if (y == 0) return 1;
int ret = modpow(x, y >> 1, md);
ret = (long long)ret * ret % md;
if (y & 1) ret = (long long)ret * x % md;
return ret;
}
int n, m, k;
int dp[101][101][131], pre[101][101][131][3];
int dist[202][202];
int a[101][101];
string ans[202];
int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, -1, 1};
void calc(int x, int y) {
dist[(x * m + y)][(x * m + y)] = a[x][y];
set<pair<int, int> > st;
st.insert(make_pair(a[x][y], (x * m + y)));
while (st.begin() != st.end()) {
int cur = st.begin()->second, cos = st.begin()->first;
st.erase(st.begin());
if (dist[(x * m + y)][cur] != cos) continue;
int nx = cur / m, ny = cur % m;
for (int i = 0; i < 4; i++) {
int tx = nx + dx[i], ty = ny + dy[i];
if (tx < 0 || ty < 0 || tx >= n || ty >= m ||
dist[(x * m + y)][(tx * m + ty)] <=
dist[(x * m + y)][(nx * m + ny)] + a[tx][ty])
continue;
dist[(x * m + y)][(tx * m + ty)] =
dist[(x * m + y)][(nx * m + ny)] + a[tx][ty];
st.insert(make_pair(dist[(x * m + y)][(tx * m + ty)], (tx * m + ty)));
}
}
}
int getdist(int x1, int y1, int x2, int y2) {
return dist[x1 * m + y1][x2 * m + y2];
}
void print(int x, int y, int mask) {
ans[x][y] = 'X';
if (pre[x][y][mask][0] == 0)
print(pre[x][y][mask][1], pre[x][y][mask][2], mask);
else if (pre[x][y][mask][0] == 1)
print(x, y, pre[x][y][mask][1]), print(x, y, pre[x][y][mask][2]);
}
int main() {
memset(pre, inf, sizeof(pre));
memset(dist, inf, sizeof(dist));
memset(dp, inf, sizeof(dp));
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) calc(i, j), ans[i].push_back('.');
for (int i = 0; i < k; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
dp[x][y][1 << i] = a[x][y];
}
for (int iter = 0; iter <= 222; iter++)
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int mask = 0; mask < (1 << k); mask++) {
for (int sub = mask; sub; sub = sub - 1 & mask) {
int v = dp[i][j][sub] + dp[i][j][mask ^ sub] - a[i][j];
if (v < dp[i][j][mask])
dp[i][j][mask] = v, pre[i][j][mask][0] = 1,
pre[i][j][mask][1] = sub, pre[i][j][mask][2] = mask ^ sub;
}
for (int k = 0; k < 4; k++) {
int x = i + dx[k], y = j + dy[k];
if (x < 0 || y < 0 || x >= n || y >= m) continue;
if (dp[x][y][mask] + getdist(i, j, x, y) - a[x][y] < dp[i][j][mask])
dp[i][j][mask] = dp[x][y][mask] + getdist(i, j, x, y) - a[x][y],
pre[i][j][mask][0] = 0, pre[i][j][mask][1] = x,
pre[i][j][mask][2] = y;
}
}
int ansv = inf;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) ansv = min(ansv, dp[i][j][(1 << k) - 1]);
cout << ansv << endl;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (dp[i][j][(1 << k) - 1] == ansv) {
print(i, j, (1 << k) - 1);
for (int i = 0; i < n; i++) cout << ans[i] << endl;
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 29;
const int N = 128;
int a[N][N];
int mrk[N][N];
int n, m, k;
int u[N], v[N];
long long dp[1 << 7][N][N];
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, -1, 0, 1};
struct Nd {
int first, second, b;
long long c;
Nd(int first, int second, int b, long long c)
: first(first), second(second), b(b), c(c) {}
Nd(){};
bool operator>(const Nd &nd) const { return c > nd.c; }
};
Nd fr[1 << 7][N][N];
char ans[N][N] = {0};
void Tr(int b, int first, int second) {
if (b == 0) return;
Nd &nd = fr[b][first][second];
int nx = nd.first, ny = nd.second, nb = nd.b;
ans[first][second] = 'X';
if (nx == -1) return;
Tr(nb, nx, ny);
Tr(b ^ nb, first, second);
}
int main() {
cin >> n >> m >> k;
for (int i = (0); i < (int)(n); i++)
for (int j = (0); j < (int)(m); j++) cin >> a[i][j];
for (int b = (0); b < (int)(1 << k); b++)
for (int first = (0); first < (int)(n); first++)
for (int second = (0); second < (int)(m); second++)
dp[b][first][second] = INF;
memset(mrk, -1, sizeof(mrk));
for (int i = (0); i < (int)(k); i++) {
int first, second;
cin >> first >> second;
first--;
second--;
u[i] = first;
v[i] = second;
mrk[first][second] = i;
dp[1 << i][first][second] = a[first][second];
fr[1 << i][first][second].first = -1;
}
for (int b = (1); b < (int)(1 << k); b++) {
for (int q = ((b - 1) & b); q; q = ((q - 1) & b)) {
for (int first = (0); first < (int)(n); first++)
for (int second = (0); second < (int)(m); second++) {
long long &res = dp[b][first][second];
for (int r = (0); r < (int)(4); r++) {
int nx = first + dx[r];
int ny = second + dy[r];
if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
long long tmp = dp[q][first][second] + dp[b ^ q][nx][ny];
if (tmp < res) {
res = tmp;
fr[b][first][second] = Nd(nx, ny, b ^ q, dp[b ^ q][nx][ny]);
}
}
}
}
priority_queue<Nd, vector<Nd>, greater<Nd> > q;
for (int first = (0); first < (int)(n); first++)
for (int second = (0); second < (int)(m); second++) {
if (dp[b][first][second] != INF) {
q.push(Nd(first, second, b, dp[b][first][second]));
}
}
while (!q.empty()) {
Nd nd = q.top();
q.pop();
int first = nd.first, second = nd.second, b = nd.b;
long long c = nd.c;
if (c > dp[b][first][second]) continue;
for (int r = (0); r < (int)(4); r++) {
int nx = first + dx[r];
int ny = second + dy[r];
if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
long long tmp = c + a[nx][ny];
int nb = b;
if (dp[nb][nx][ny] > tmp) {
dp[nb][nx][ny] = tmp;
fr[nb][nx][ny] = nd;
q.push(Nd(nx, ny, nb, tmp));
}
}
}
}
long long Min = INF;
int X, Y;
for (int first = (0); first < (int)(n); first++)
for (int second = (0); second < (int)(m); second++)
if (dp[(1 << k) - 1][first][second] < Min) {
Min = dp[(1 << k) - 1][first][second];
X = first;
Y = second;
}
cout << Min << endl;
for (int i = (0); i < (int)(n); i++)
for (int j = (0); j < (int)(m); j++) ans[i][j] = '.';
Tr((1 << k) - 1, X, Y);
for (int i = (0); i < (int)(n); i++) puts(ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int a[1008][1008];
int f[305][108][108], be[10008];
int dx[4] = {0, 0, 1, -1}, dy[4] = {1, -1, 0, 0};
bool in[108][108], t[108][108];
struct arr {
int x, y;
} h[1000008], b[108];
struct brr {
int a, b, c;
brr() {}
brr(int a1, int b1, int c1) {
a = a1;
b = b1;
c = c1;
}
} pre[152][108][108];
void Init() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &a[i][j]);
for (int i = 1; i <= k; i++) scanf("%d%d", &b[i].x, &b[i].y);
for (int i = 1; i <= k; i++) be[1 << i - 1] = i;
}
void Dfs(int s, int x, int y) {
t[x][y] = 1;
if (!s || x < 1 || y < 1 || x > n || y > m || a[x][y] == f[s][x][y]) return;
brr v = pre[s][x][y];
Dfs(v.a, v.b, v.c);
Dfs(s - v.a, x, y);
}
void Work() {
for (int s = 1; s <= (1 << k) - 1; s++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) f[s][i][j] = 214748364;
for (int s = 1; s <= (1 << k) - 1; s++) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int k = 0; k <= 3; k++) {
int tx = i + dx[k], ty = j + dy[k];
if (tx < 1 || tx > n || ty < 1 || ty > m) continue;
for (int s1 = (s - 1) & s; s1; s1 = (s1 - 1) & s) {
if (f[s][i][j] > f[s - s1][tx][ty] + f[s1][i][j]) {
f[s][i][j] = f[s1][i][j] + f[s - s1][tx][ty];
pre[s][i][j] = brr(s - s1, tx, ty);
}
}
}
int l = 1, r = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) in[i][j] = 0;
if (be[s]) {
int k = be[s];
h[++r].x = b[k].x;
h[r].y = b[k].y;
in[b[k].x][b[k].y] = 1;
f[s][b[k].x][b[k].y] = a[b[k].x][b[k].y];
} else {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) h[++r].x = i, h[r].y = j, in[i][j] = 1;
}
while (l <= r) {
arr u = h[l++];
for (int i = 0; i <= 3; i++) {
int tx = u.x + dx[i], ty = u.y + dy[i];
if (tx < 1 || tx > n || ty < 1 || ty > m) continue;
if (f[s][tx][ty] > f[s][u.x][u.y] + a[tx][ty]) {
f[s][tx][ty] = f[s][u.x][u.y] + a[tx][ty];
pre[s][tx][ty] = brr(s, u.x, u.y);
if (!in[tx][ty]) {
in[tx][ty] = 1;
h[++r].x = tx;
h[r].y = ty;
}
}
}
in[u.x][u.y] = 0;
}
}
int ans = 214748364, x = 0, y = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (f[(1 << k) - 1][i][j] < ans) {
ans = f[(1 << k) - 1][i][j];
x = i;
y = j;
}
printf("%d\n", ans);
int s = (1 << k) - 1;
Dfs(s, x, y);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
if (t[i][j])
printf("X");
else
printf(".");
printf("\n");
}
}
int main() {
Init();
Work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ans[1010][1010];
int al[1010];
struct node {
int id;
int v;
} den[1010], qian[1010];
int dl = 0;
int ql = 0;
bool cmp(node a, node b) { return a.v > b.v; }
int main() {
int n;
scanf("%d", &n);
;
int m;
scanf("%d", &m);
;
double cost = 0;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
;
int y;
scanf("%d", &y);
;
if (y == 1) {
den[dl].id = i;
den[dl++].v = x;
} else {
qian[ql].id = i;
qian[ql++].v = x;
}
}
sort(den, den + dl, cmp);
int i;
for (i = 0; i < m - 1 && i < dl; i++) {
ans[i][0] = den[i].id;
al[i] = 1;
cost += den[i].v / 2.0;
}
if (i < m - 1) {
int j;
for (j = 0; i < m - 1; i++, j++) {
ans[i][0] = qian[j].id;
al[i] = 1;
cost += qian[j].v;
}
for (; j < ql; j++) {
ans[m - 1][al[m - 1]++] = qian[j].id;
cost += qian[j].v;
}
} else {
int vmin = 0x3FFFFFFF;
for (int j = 0; i < dl; i++, j++) {
ans[m - 1][j] = den[i].id;
al[m - 1]++;
cost += den[i].v;
if (den[i].v < vmin) vmin = den[i].v;
}
for (int j = 0; j < ql; j++) {
ans[m - 1][al[m - 1]++] = qian[j].id;
cost += qian[j].v;
if (vmin != 0x3FFFFFFF && qian[j].v < vmin) vmin = qian[j].v;
}
if (vmin != 0x3FFFFFFF) cost -= vmin / 2.0;
}
printf("%.1lf\n", cost);
for (int i = 0; i < m; i++) {
printf("%d", al[i]);
for (int j = 0; j < al[i]; j++) {
printf(" %d", ans[i][j]);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, n;
scanf("%d%d", &n, &k);
vector<int> a(n), b(n), distributed(n), p(n);
vector<vector<int> > cart(k);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &a[i], &b[i]);
distributed[i] = 0;
p[i] = i;
}
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
if (a[p[i]] < a[p[j]]) {
swap(p[i], p[j]);
}
}
}
int cart_ptr = 0;
for (int i = 0; i < n && cart_ptr < k; ++i) {
if (b[p[i]] == 1) {
distributed[p[i]] = 1;
cart[cart_ptr].push_back(p[i]);
++cart_ptr;
}
}
deque<int> available;
for (int i = 0; i < n; ++i) {
if (!distributed[p[i]]) {
available.push_back(p[i]);
}
}
while (cart_ptr < k) {
cart[cart_ptr].push_back(available.front());
available.pop_front();
++cart_ptr;
}
while (!available.empty()) {
cart[k - 1].push_back(available.front());
available.pop_front();
}
long long ans = 0;
for (int i = 0; i < k; ++i) {
int min_cost = 2000000000;
for (int j = 0; j < (int)cart[i].size(); ++j) {
ans += a[cart[i][j]] * 2;
min_cost = min(min_cost, a[cart[i][j]]);
}
if (b[cart[i][0]] == 1) {
ans -= min_cost;
}
}
cout << ans / 2;
if (ans % 2 == 0) {
cout << ".0" << endl;
} else {
cout << ".5" << endl;
}
for (int i = 0; i < k; ++i) {
cout << cart[i].size();
for (int j = 0; j < (int)cart[i].size(); ++j) {
cout << ' ' << cart[i][j] + 1;
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct sort_pred {
bool operator()(const std::pair<int, int> &left,
const std::pair<int, int> &right) {
return left.first > right.first;
}
};
int main() {
int n, k;
cin >> n >> k;
int num = n / k;
int cart = 1;
vector<pair<int, int> > one, rest;
vector<int> ans;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
if (b == 1)
one.push_back(pair<int, int>(a, i + 1));
else
rest.push_back(pair<int, int>(a, i + 1));
}
std::sort(one.begin(), one.end(), sort_pred());
int i;
double tcost = 0;
for (i = 0; i < min(k - 1, (int)one.size()); i++) {
pair<int, int> t = one[i];
tcost += t.first / 2.0;
ans.push_back(t.second);
}
vector<int> final;
if (i < one.size()) {
int m = (int)1e9;
while (i < one.size()) {
pair<int, int> t = one[i];
tcost += t.first;
m = min(m, t.first);
final.push_back(t.second);
i++;
}
i = 0;
while (i < rest.size()) {
pair<int, int> t = rest[i];
tcost += t.first;
m = min(m, t.first);
final.push_back(t.second);
i++;
}
tcost = tcost - m / 2.0;
} else {
int j = 0;
for (i; i < k - 1; i++) {
pair<int, int> t = rest[j];
tcost += t.first;
ans.push_back(t.second);
j++;
}
for (j; j < rest.size(); j++) {
pair<int, int> t = rest[j];
tcost += t.first;
final.push_back(t.second);
}
}
printf("%.1f\n", tcost);
for (i = 0; i < ans.size(); i++) {
cout << 1 << " " << ans[i] << endl;
}
cout << final.size() << " ";
for (i = 0; i < final.size(); i++) {
cout << final[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, N, k;
struct Node {
int c, id;
bool operator<(const Node &b) const { return c > b.c; }
} p[1005], q[1005];
int ans[1001][1001], r[1001], mi[1001];
int main() {
while (~scanf("%d%d", &N, &k)) {
n = m = 0;
double sum = 0.0;
for (int i = 1; i <= N; i++) {
int c, t;
scanf("%d%d", &c, &t);
sum += (double)c;
if (t == 1) {
p[n].c = c;
p[n++].id = i;
} else {
q[m].c = c;
q[m++].id = i;
}
}
sort(p, p + n);
sort(q, q + m);
memset(r, 0, sizeof(r));
int hav = min(k, n);
for (int i = 0; i < hav; i++) {
ans[i][r[i]++] = p[i].id;
mi[i] = p[i].c;
}
if (k < n) {
for (int i = k; i < n; i++) {
ans[k - 1][r[k - 1]++] = p[i].id;
mi[k - 1] = p[i].c;
}
} else {
for (int i = n; i < k; i++) {
ans[i][r[i]++] = q[m - 1].id;
mi[i] = q[--m].c;
}
}
int tp = 0;
for (int i = 0; i < m; i++) {
int f = 0;
for (int j = 0; j < k; j++) {
if (q[i].c >= mi[j]) {
f = 1;
ans[j][r[j]++] = q[i].id;
break;
}
}
if (!f) {
ans[k - 1][r[k - 1]++] = q[i].id;
mi[k - 1] = q[i].c;
}
}
for (int i = 0; i < min(k, n); i++) sum -= 0.5 * (double)mi[i];
printf("%.1f\n", sum);
for (int i = 0; i < k; i++) {
printf("%d", r[i]);
for (int j = 0; j < r[i]; j++) printf(" %d", ans[i][j]);
puts("");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline int cMin(T& a, T b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
inline int cMax(T& a, T b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
inline string to_str(T v) {
ostringstream os;
os << v;
return os.str();
}
const double pi = acos(-1.0);
const double eps = 1e-9;
template <class T>
inline T isqr(T v) {
return v * v;
}
template <class T>
inline T iabs(T v) {
return v < 0 ? -v : v;
}
template <class T>
inline int isgn(T v) {
return iabs(v) <= eps ? 0 : (v < 0 ? -1 : 1);
}
template <typename T>
inline T next() {
static char buf[64];
scanf("%s", buf);
istringstream is(buf);
T v;
is >> v;
return v;
}
inline int nextInt() {
int v = 0;
scanf("%d", &v);
return v;
}
int N, K;
pair<int, pair<int, int> > src[1024];
vector<pair<int, pair<int, int> > > adj[1024];
int curK = 0;
vector<pair<int, pair<int, int> > > Rem;
vector<pair<int, pair<int, int> > > S, P;
long long total = 0;
int main(int argc, char* argv[]) {
scanf("%d%d", &N, &K);
for (int i = 1; i <= (int)(N); ++i) {
pair<int, pair<int, int> > t;
scanf("%d%d", &t.first, &t.second.first);
total += t.first;
t.second.second = i;
if (t.second.first == 1) {
S.push_back(t);
} else
P.push_back(t);
}
total *= 2;
sort(S.begin(), S.end());
reverse(S.begin(), S.end());
while (S.size() > K) {
P.push_back(S.back());
S.pop_back();
}
sort(P.begin(), P.end());
int need = K - (int)S.size();
curK = S.size();
for (int i = 0; i < (int)(curK); ++i) {
adj[i].push_back(S[i]);
}
for (int i = 0; i < (int)(curK); ++i) {
if (P.size() > need) {
if (adj[i].begin()->first < P.back().first) {
adj[i].push_back(P.back());
P.pop_back();
}
}
}
for (int i = curK; i < K; ++i) {
adj[i].push_back(P.back());
P.pop_back();
}
while (!P.empty()) {
adj[K - 1].push_back(P.back());
P.pop_back();
}
for (int i = 0; i < (int)(curK); ++i) {
sort(adj[i].begin(), adj[i].end());
total -= adj[i].begin()->first;
}
printf("%s.%d\n", to_str(total / 2).c_str(), (total & 1) ? 5 : 0);
for (int i = 0; i < (int)(K); ++i) {
printf("%d", (int)adj[i].size());
for (int k = 0; k < (int)(adj[i].size()); ++k)
printf(" %d", adj[i][k].second.second);
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
vector<pair<pair<long long, long long>, long long> > v;
long long q, w;
int cou = 0;
for (long long i = 0; i < n; i++) {
cin >> q >> w;
if (w == 1) cou++;
v.push_back(make_pair(make_pair(q, w), i + 1));
}
sort(v.begin(), v.end());
long double p = 0;
vector<int> ans;
for (int i = v.size() - 1; i >= 0; i--) {
if (k == 1) {
break;
}
if ((v[i]).first.second == 1) {
p += ((double)((v[i]).first.first)) / 2;
ans.push_back((v[i]).second);
v.erase(v.begin() + i);
k--;
cou--;
} else if (cou < k - 1) {
p += (v[i]).first.first;
ans.push_back((v[i]).second);
v.erase(v.begin() + i);
k--;
}
}
bool isit = false;
for (int i = v.size() - 1; i >= 0; i--) {
if ((v[i]).first.second == 1) {
isit = true;
break;
}
}
if (isit) {
p -= ((double)v[0].first.first) / 2;
}
for (int i = 0; i < v.size(); i++) {
p += v[i].first.first;
}
cout.precision(1);
cout.setf(ios::fixed | ios::showpoint);
cout << p << endl;
for (int i = 0; i < ans.size(); i++) {
cout << "1 " << ans[i] << endl;
}
cout << v.size();
for (int i = 0; i < v.size(); i++) {
cout << " " << v[i].second;
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const size = 1000 + 5;
pair<int, int> tab[size], pan[size];
int main() {
int n, i, j, k, m, hor = 0, c, t, kt, kp;
long long sum = 0;
scanf("%d %d", &n, &k);
kt = kp = 0;
for (i = 0; i < n; i++) {
scanf("%d %d", &c, &t);
if (t == 1) {
tab[kt].first = 2 * c;
tab[kt++].second = i + 1;
} else {
pan[kp].first = 2 * c;
pan[kp++].second = i + 1;
}
}
sort(tab, tab + kt);
sort(pan, pan + kp);
if (kt < k) {
for (i = 0; i < kt; i++) sum += tab[i].first / 2;
for (i = 0; i < kp; i++) sum += pan[i].first;
if (sum % 2 == 0)
printf("%I64d.0\n", sum / 2);
else
printf("%I64d.5\n", sum / 2);
for (i = 0; i < kt; i++) printf("1 %d\n", tab[i].second);
for (i = 0; i < k - 1 - kt; i++) printf("1 %d\n", pan[i].second);
printf("%d ", kp - (k - 1 - kt));
for (i = k - 1 - kt; i < kp; i++)
printf("%d%c", pan[i].second, " \n"[i == kp - 1]);
} else {
for (i = 0; i < k - 1; i++) sum += tab[kt - 1 - i].first / 2;
for (i = k - 1; i < kt; i++) sum += tab[kt - 1 - i].first;
for (i = 0; i < kp; i++) sum += pan[i].first;
if (kt == 0) tab[0].first = 2 * 1000 * 1000 * 1000 + 1;
if (kp == 0) pan[0].first = 2 * 1000 * 1000 * 1000 + 1;
sum -= min(pan[0].first, tab[0].first) / 2;
if (sum % 2 == 0)
printf("%I64d.0\n", sum / 2);
else
printf("%I64d.5\n", sum / 2);
for (i = 0; i < k - 1; i++) printf("1 %d\n", tab[kt - 1 - i].second);
printf("%d ", n - k + 1);
for (i = k - 1; i < kt; i++)
printf("%d%c", tab[kt - 1 - i].second, " \n"[i == n - 1]);
for (i = 0; i < kp; i++) printf("%d%c", pan[i].second, " \n"[i == kp - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 10;
int c[maxn], t[maxn], idx[maxn], ans[maxn];
int n, k;
bool cmp(int i, int j) { return t[i] < t[j] || t[i] == t[j] && c[i] > c[j]; }
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &c[i], &t[i]);
idx[i] = i;
}
sort(idx, idx + n, cmp);
int cnt = 0;
while (cnt < n && t[idx[cnt]] == 1) ++cnt;
long long half = 0, full = 0;
if (cnt < k) {
for (int i = 0; i < cnt; ++i) {
ans[idx[i]] = i;
half += c[idx[i]];
}
for (int i = cnt; i < k; ++i) {
ans[idx[i]] = i;
full += c[idx[i]];
}
for (int i = k; i < n; ++i) {
ans[idx[i]] = k - 1;
full += c[idx[i]];
}
} else {
for (int i = 0; i < k - 1; ++i) {
ans[idx[i]] = i;
half += c[idx[i]];
}
int best = c[idx[k - 1]];
for (int i = k - 1; i < n; ++i) {
ans[idx[i]] = k - 1;
if (c[idx[i]] < best) best = c[idx[i]];
full += c[idx[i]];
}
half += best;
full -= best;
}
printf("%I64d", full + half / 2);
if (half & 1)
printf(".5\n");
else
printf(".0\n");
for (int i = 0; i < k; ++i) {
int tot = 0;
for (int j = 0; j < n; ++j)
if (ans[j] == i) ++tot;
printf("%d", tot);
for (int j = 0; j < n; ++j)
if (ans[j] == i) printf(" %d", j + 1);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
using namespace std;
double EPS = 1e-7;
vector<pair<int, int> > a, b;
vector<int> res[3000];
int m[3000];
bool B[3000];
int main() {
int n, k;
scanf("%d%d", &n, &k);
long long s = 0;
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
s += x;
if (y == 1)
a.push_back(make_pair(x, i + 1));
else
b.push_back(make_pair(x, i + 1));
}
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
for (int i = 0; i < min(k, (int)a.size()); i++) {
res[i].push_back(a[i].second);
B[i] = 1;
m[i] = a[i].first;
}
for (int i = k; i < a.size(); i++) {
b.push_back(a[i]);
}
sort(b.begin(), b.end());
for (int i = a.size(); i < k; i++) {
res[i].push_back(b[b.size() - 1].second);
m[i] = b[b.size() - 1].first;
b.erase(b.begin() + b.size() - 1);
}
for (int i = 0; i < b.size(); i++) {
res[k - 1].push_back(b[i].second);
m[k - 1] = min(m[k - 1], b[i].first);
}
double Res = s;
for (int i = 0; i < k; i++) {
if (B[i]) Res -= m[i] / 2.0;
}
printf("%.1f\n", Res);
for (int i = 0; i < k; i++) {
printf("%d ", res[i].size());
for (int j = 0; j < res[i].size(); j++) {
printf("%d ", res[i][j]);
}
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
long long int k;
cin >> n >> k;
vector<pair<long long int, long long int>> ones, twos;
long long int cost = 0;
long double ans = 0;
vector<long long int> v[1005];
long type;
for (long long int i = 0; i < n; i++) {
cin >> cost >> type;
if (type == 1)
ones.push_back({cost, i + 1});
else
twos.push_back({cost, i + 1});
}
sort(ones.begin(), ones.end());
sort(twos.begin(), twos.end());
long long int p = min(k - 1, (long long int)ones.size());
long long int flag = 0;
long long int u = 0;
if (p == k - 1)
flag = 1, u = 1;
else
flag = p;
while (p >= 1) {
double y = (*(--ones.end())).first;
v[p].push_back((*(--ones.end())).second);
ans += double((y / 2));
ones.pop_back();
p -= 1;
}
long long int ans2 = 0;
long long int mi = 10000000007;
long long int l = 0;
if (u == 1) {
while (ones.size()) {
l = 1;
v[k].push_back((*(--ones.end())).second);
ans2 += (*(--ones.end())).first;
mi = min(mi, (*(--ones.end())).first);
ones.pop_back();
}
while (twos.size()) {
v[k].push_back((*(--twos.end())).second);
ans2 += (*(--twos.end())).first;
mi = min(mi, (*(--twos.end())).first);
twos.pop_back();
}
ans += ans2;
if (l == 1) {
ans -= mi;
double g = mi;
ans += double((g / 2));
}
} else {
long long int z = flag + 1;
while (z <= k - 1) {
v[z].push_back((*(--twos.end())).second);
ans += (*(--twos.end())).first;
twos.pop_back();
z++;
}
while (twos.size()) {
v[k].push_back((*(--twos.end())).second);
ans += (*(--twos.end())).first;
twos.pop_back();
}
}
cout << fixed << setprecision(1) << ans << "\n";
for (long long int i = 1; i <= k; i++) {
cout << v[i].size() << " ";
for (auto j : v[i]) cout << j << " ";
cout << "\n";
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.