text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#define X first
#define Y second
#define nl '\n'
#define AC return 0
#define pb(a) push_back(a)
#define mst(a,b) memset(a, b, sizeof a)
#define rep(i,n) for(int i = 0; (i)<(n); i++)
#define rep1(i,n) for(int i = 1; (i)<=(n); i++)
#define scd(a) scanf("%lld", &a)
#define scdd(a,b) scanf("%lld%lld", &a, &b)
#define scs(s) scanf("%s", s)
//#pragma GCC optimize(2)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;
const ll INF = (ll)0x3f3f3f3f3f3f3f, MAX = 9e18, MIN = -9e18;
const int N = 1e6+10, M = 2e6+10, mod = 1e9+7, inf = 0x3f3f3f;
pll a[N];
ll calc(ll r1, ll c1, ll r2, ll c2)
{
if(r1 - c1 == r2 - c2)
{
if((r1+c1)&1) return 0;
return r2-r1;
}
c2 -= c1-1;
r2 -= r1-1;
if((r1+c1)&1) return (r2-c2+1)/2;
else return (r2-c2)/2;
}
int main()
{
IOS;
int _;
cin>>_;
while(_--)
{
ll n, ans = 0;
cin>>n;
rep1(i, n) cin>>a[i].X;
rep1(i, n) cin>>a[i].Y;
sort(a+1, a+1+n);
a[0] = {1, 1};
rep1(i, n)
{
ans += calc(a[i-1].X, a[i-1].Y, a[i].X, a[i].Y);
}
cout<<ans<<nl;
}
AC;
}
|
// 1506f.cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void solve() {
int n;
cin >> n;
vector<pair<ll, ll>> v(n);
for (int i = 0; i < n; i++)
cin >> v[i].first;
for (int i = 0; i < n; i++)
cin >> v[i].second;
sort(v.begin(), v.end());
auto last = make_pair(1LL, 1LL);
int ans = 0;
for (int i = 0; i < n; i++) {
if (v[i] == last)
continue;
if (v[i].first - last.first == v[i].second - last.second) {
ans += (last.first + last.second) % 2 == 0 ? v[i].first - last.first : 0;
last = v[i];
continue;
}
ll dr = v[i].first - last.first;
ll dc = v[i].second - last.second;
// --d;
if ((last.first + last.second) % 2 == 0) {
ans += (dr - dc)/2;
} else {
ans += (dr - dc + 1)/2;
}
last = v[i];
}
cout << ans << endl;
}
int main() {
int tc;
cin >> tc;
while (tc--)
solve();
} |
#include <bits/stdc++.h>
#define przxct ""
#define fto(i,j,h) for (int i=j; i<=h; ++i)
#define maxn 200005
#define ll long long
#define pi 3.141592653589
using namespace std;
int test, n;
pair<int, int> a[maxn];
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> test;
while (test--)
{
cin >> n;
fto(i,1,n) cin >> a[i].first;
fto(i,1,n) cin >> a[i].second;
++n;
a[n] = make_pair(1, 1);
sort(a+1, a+n+1);
int rs = 0;
fto(i,1,n)
{
if (a[i].first == 1 && a[i].second == 1) continue;
int x = (a[i].first - a[i-1].first) - (a[i].second - a[i-1].second);
if (x == 0)
{
if ((a[i-1].first + a[i-1].second) % 2 == 0) rs += a[i].first - a[i-1].first;
}
else rs += (x + 1 - ((a[i-1].first + a[i-1].second) % 2 == 0)) / 2;
//cout << rs << '\n';
}
cout << rs << '\n';
}
return 0;
}
|
//2*10^9 -- int
//9*10^18 -- long long int
//10^38 -- __int128_t
//we also have long double
/*A better way to compare floating point numbers is to assume that
two numbers are equal if the difference between them is less than ε, where ε is a small number.(ε=10−9) */
#include<bits/stdc++.h>
using namespace std;
typedef unsigned long long int ull;
typedef long long int ll;
#define endl "\n"
#define sp " "
#define PI 3.14159265358979323846264338327950L
const ll M=1e9+7;
//to handle when remainder is -neg we add + M
//but when rem is +pos that time also we add so use %M
//so it will work for both
ll mod(ll n){
return (n%M + M)%M;
}
ll modAdd(ll a, ll b){
return mod(mod(a)+mod(b));
}
ll modMul(ll a, ll b){
return mod(mod(a)*mod(b));
}
ll modMinus(ll a, ll b){
return mod(mod(a)-mod(b));
}
ll modpow(ll x, ll n)
{
if (n == 0)
return 1%M;
if (n == 1)
return x%M;
ll u = modpow(x,n/2);
u = modMul(u,u);
if (n%2)
u = modMul(u,x);
return u;
}
ll gcd(ll a,ll b){
if(b==0)
return a;
return gcd(b,a%b);
}
bool isPrime(ll n){
int end = sqrt(n);
for(int i=2;i<=end;i++)
if(n%i==0)
return false;
return true;
}
int getParent(vector<int>&parent,int s){
if(parent[s]==s)
return s;
return getParent(parent,parent[s]);
}
vector<int> primeNumbers;
void sieve(){
int limit=1e5;
vector<bool> prime(limit,true);
for(ll i=2;i<limit;i++){
if(prime[i]){
primeNumbers.push_back(i);
for(ll j=i*i;j<limit;j=j+i)
prime[j]=false;
}
}
}
int N = 2e7+10;
vector<int> primeFactors(N,0);
void calPrimeFactors(){
for(ll i = 2;i<N;i++){
if(primeFactors[i]==0){
for(ll j=i;j<N;j+=i){
primeFactors[j]+=1;
}
}
}
}
void solve(){
int n;
cin>>n;
vector<pair<int,int>> points(n+1);
points[0].first=1;
points[0].second=1;
for(int i=1;i<=n;i++)
cin>>points[i].first;
for(int i=1;i<=n;i++)
cin>>points[i].second;
sort(points.begin(),points.end());
int ans=0;
for(int i=0;i<n;i++){
int x1 = points[i].first;
int y1 = points[i].second;
int x2 = points[i+1].first;
int y2 = points[i+1].second;
int dist1 = x1-y1;
int dist2 = x2-y2;
//cout<<"x1:"<<x1<<" y1:"<<y1<<", x2:"<<x2<<", y2:"<<y2<<endl;
//cout<<"d1:"<<dist1<<", d2:"<<dist2<<endl;
if(dist1==dist2){
if(dist1%2==0)
ans+=(x2-x1);
}else{
if(dist1%2){
if((dist2-dist1)%2)
ans+=1;
ans+=(dist2-dist1)/2;
}else{
ans+=(dist2-dist1)/2;
}
}
//cout<<"ans:"<<ans<<endl;
}
cout<<ans<<endl;
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
// freopen("inputf.txt","r",stdin);
// freopen("outputf.txt","w",stdout);
int t=1;
cin>>t;
while(t--){
solve();
}
return 0;
} |
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#define x first
#define y second
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const int N = 200010;
int n;
PII e[N];
int main()
{
int _;
scanf("%d", &_);
while(_ --)
{
scanf("%d", &n);
for(int i = 1; i <= n; i ++) scanf("%d", &e[i].x);
for(int i = 1; i <= n; i ++) scanf("%d", &e[i].y);
e[0].x = e[0].y = 1;
sort(e + 1, e + n + 1);
int res = 0;
for(int i = 1; i <= n; i ++)
{
int dx = e[i].x - e[i - 1].x, dy = e[i].y - e[i - 1].y;
int t = dx - dy;
if(!t)
{
if((e[i].x - e[i].y) % 2 == 0) res += dx;
}
else
{
if((e[i - 1].x - e[i - 1].y) % 2) res += t + 1 >> 1;
else res += t >> 1;
}
}
printf("%d\n", res);
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pl pair<ll,ll>
#define pll pair<ll,pl>
void solve()
{
ll n,i,prevx,prevy,row,col,ans=0;
vector <pl> v;
cin>>n;
ll R[n],C[n];
for(i=0;i<n;i++)
cin>>R[i];
for(i=0;i<n;i++)
cin>>C[i];
for(i=0;i<n;i++)
v.push_back({R[i],C[i]});
sort(v.begin(),v.end());
prevx = 1;
prevy = 1;
for(i=0;i<n;i++)
{
if(v[i].second < prevy)
{
while(true)
{
;
}
}
row = v[i].first - prevx;
col = v[i].second - prevy;
if(row < col)
{
while(true)
{
;
}
}
if(row == col)
{
if((prevx+prevy)%2 == 0)
ans += row;
prevx = v[i].first;
prevy = v[i].second;
}
else
{
if((prevx+prevy)%2 == 0)
prevx++;
prevx += col;
prevy += col;
ans += (v[i].first - prevx + 1)/2;
prevx = v[i].first;
}
}
cout<<ans<<"\n";
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin>>t;
//t=1;
while(t--)
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 200007;
int T,N;
pair<int,int> p[M];
int main(){
cin>>T;
while(T--){
int costr=0,x1,x2,y1,y2;
cin>>N;
for(int i=0;i<N;i++) cin>>p[i].first;
for(int i=0;i<N;i++) cin>>p[i].second;
sort(p,p+N);
x1=1,x2=1;
for(int i=0;i<N;i++){
y1=p[i].first;
y2=p[i].second;
if((y1-x1==y2-x2)&& (x1+x2)%2==0) costr+=(y2-x2);
else if(y2==x2 && ((x1+x2)%2)!=0) costr+=((y1-x1)+((x1+x2)%2))/2;
else {
if((x1+x2)%2==0) x1++;
costr+=(y1-x1-y2+x2+1)/2;
}
x1=p[i].first;
x2=p[i].second;
}
cout<<costr<<endl;
}
}
|
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#include <algorithm>
#include <cstdio>
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <cmath>
#include <iomanip>
#include <sstream>
#include <string>
#include <vector>
#include <stack>
#include <algorithm>
#include <map>
#include <string>
#include <queue>
#include <list>
#include <set>
#include <ctime>
#include <queue>
#include <cstring>
#include <unordered_map>
#include <fstream>
#include <bitset>
#include <functional>
#include <cassert>
//#include "windows.h"
//#include <conio.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3fll;
#define rep(i, l, r) for(ll i = l, i##end = r; i <= i##end; i++)
#define repo(i, l, r) for(ll i = l, i##end = r; i < i##end; i++)
#define per(i, l, r) for(ll i = l, i##end = r; i >= i##end; i--)
#define pero(i, l, r) for(ll i = l, i##end = r; i > i##end; i--)
#define mm1(a) memset(a, -1, sizeof(a))
#define mm2(a) memset(a, 0, sizeof(a))
#define mm3(a) memset(a, inf, sizeof(a))
#define mm4(a) memset(a, INF, sizeof(a))
#define swap(x,y) x^=y^=x^=y
#define debug(x) cerr << #x << " : " << x << " " << endl
#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
int dir[4][2] = { {-1, 0}, {0, -1}, {1, 0}, {0, 1} };
vector<pii>v;
bool cmp(pii n1, pii n2) {
if (n1.first != n2.first)
return n1.first < n2.first;
return n1.second < n2.second;
}
int main()
{
IOS;
int t;
cin >> t;
while (t--) {
v.clear();
int n;
cin >> n;
pii p;
p.first = 1, p.second = 1;
v.push_back(p);
rep(i, 1, n) {
cin >> p.first;
p.second = 0;
v.push_back(p);
}
rep(i, 1, n)
cin >> v[i].second;
sort(v.begin(), v.end(), cmp);
//for (int i = 0; i < v.size(); i++)
// cout << "--: " << v[i].first << " " << v[i].second << endl;
int res = 0;
for (int i = 1; i < v.size(); i++) {
if (v[i].first - v[i].second == v[i - 1].first - v[i - 1].second) {
if ((v[i].first + v[i].second) % 2 == 0)
res += v[i].first - v[i - 1].first;
}
else {
int num2 = v[i].first - v[i].second;
int num1 = v[i - 1].first - v[i - 1].second;
if (num2 % 2)
res += (num2 - num1) / 2;
else
res += (num2 - num1 + 1) / 2;
}
}
cout << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
}
void ran() {
srand(chrono::steady_clock::now().time_since_epoch().count());
}
long long get_rand() {
long long a = rand();
long long b = rand();
return a * (RAND_MAX + 1ll) + b;
}
void usaco() {
freopen("problem.in", "r", stdin);
freopen("problem.out", "w", stdout);
}
template<typename T>
using min_pq = priority_queue<T, vector<T>, greater<T>>;
// #define endl '\n'
// #define double long double
#define int long long
// const int MOD = 1000 * 1000 * 1000 + 7;
// const int MOD = 998244353;
int n;
const int MXN = 200005;
int r[MXN], c[MXN];
void solve() {
cin >> n;
for (int i=1; i<=n; i++) cin >> r[i];
for (int i=1; i<=n; i++) cin >> c[i];
vector<pair<int, int>> points;
points.push_back({1, 1});
for (int i=1; i<=n; i++) points.push_back({r[i], c[i]});
sort(points.begin(), points.end());
int ans = 0;
for (int i=1; i<points.size(); i++) {
int x = points[i-1].first, y = points[i-1].second;
int a = points[i].first, b = points[i].second;
int cd = x - y;
int xd = a - b;
// cout << x << ' ' << y << " to " << a << ' ' << b << endl;
if (cd == xd) {
if (cd % 2 == 0) ans += b - y;
}
else if (cd % 2 == xd % 2) {
ans += (xd - cd) / 2;
}
else {
if (cd % 2 == 0) {
ans += (xd - cd - 1) / 2;
}
else {
ans += (xd - cd + 1) / 2;
}
}
// cout << " > " << ans << endl;
}
cout << ans << endl;
}
signed main() {
ran(); fast();
int t;
cin >> t;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false); cin.tie(NULL);
int t;
cin>>t;
while(t--){
int n;
cin>>n;
long long int a[n];
long long int b[n];
vector<pair<long long int,long long int>>v;
map<int,int>mapa;
for(int i=0;i<n;i++){
cin>>a[i];
}
for(int i=0;i<n;i++){
cin>>b[i];
}
v.push_back(make_pair(0,1));
for(int i=0;i<n;i++){
v.push_back(make_pair(a[i]-b[i],a[i]));
}
sort(v.begin(),v.end());
long long int ans=0;
for(int i=1;i<v.size();i++){
long long int x1=v[i].first;
long long int x2=v[i].second;
long long int y1=v[i-1].first;
long long int y2=v[i-1].second;
if(x1>y1){
long long int res;
if(y1%2==1){
res=(x1-y1)/2;
if(x1%2==0){
res++;
}
}else{
res=(x1-y1)/2;
}
ans=ans+res;
}else{
if(x1%2==0){
ans=ans+x2-y2;
}
}
}
cout<<ans<<endl;
}
} |
#include <bits/stdc++.h>
using namespace std;
using Point = pair<int64_t, int64_t>;
int main() {
ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
int64_t t;
cin >> t;
while (t--) {
int64_t n;
cin >> n;
vector<Point> rc(n);
for (auto& [r, c] : rc) {
cin >> r;
}
for (auto& [r, c] : rc) {
cin >> c;
}
rc.emplace_back(1, 1);
sort(rc.begin(), rc.end());
auto cost = [&] (const Point& source, const Point& destination) -> int64_t {
const auto source_diagonal = source.first - source.second;
const auto destination_diagonal = destination.first - destination.second;
const auto diagonal_distance = destination_diagonal - source_diagonal;
if (source_diagonal & 1) {
return (diagonal_distance + 1) / 2;
} else {
if (destination_diagonal == source_diagonal) {
return destination.first - source.first;
} else {
return diagonal_distance / 2;
}
}
};
int64_t min_cost = 0;
for (int64_t i = 0; i < n; ++i) {
min_cost += cost(rc[i], rc[i + 1]);
}
cout << min_cost << "\n";
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int main(){
int t;
cin>>t;
while(t--)
{
int n;
cin>>n;
vector<pair<int,int>> v;
for(int i=0;i<n;i++)
{
int x;
cin>>x;
v.push_back({x,0});
}
for(int i=0;i<n;i++)
{
int x;
cin>>x;
v[i].second=x;
}
sort(v.begin(),v.end());
if(v[0]!=make_pair(1,1))
{
v.push_back({1,1});
n++;
}
sort(v.begin(),v.end());
long long ans=0;
for(int i=0;i<n-1;i++)
{
if((v[i].first-v[i].second)==(v[i+1].first-v[i+1].second))
{if((v[i].first+v[i].second)%2==0)
ans+=(v[i+1].first-v[i].first);
}
else
{
ans+=(v[i+1].first-v[i+1].second)/2-(v[i].first-v[i].second)/2;
}
}
cout<<ans<<endl;
}
} |
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vpii;
#define FOR(i, a, b) for (int i = a; i <= (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); i++)
#define FORd(i, a, b) for (int i = (b); i >= a; i--)
#define F0Rd(i, a) for (int i = (a)-1; i >= 0; i--)
#define trav(a, x) for (auto &a : x)
#define sz(x) (int)(x).size()
#define popcnt(x) __builtin_popcount(x)
#define low_bo(a, x) (lower_bound(a.begin(), a.end(), x) - a.begin())
#define up_bo(a, x) (upper_bound(a.begin(), a.end(), x) - a.begin())
#define unique(a) a.resize(unique(a.begin(), a.end()) - a.begin())
#define shuffle(a) shuffle(a.begin(), a.end(), rnd)
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()
#define ins insert
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MOD = 1000000007;
const char nl = '\n';
const int MX = 150001; //check the limits, dummy
void solve(int t) {
int n;
cin>>n;
vl r(n),c(n);
vector<pair<long,long>> rc;
F0R(i,n) {
cin>>r[i];
}
F0R(i,n) {
cin>>c[i];
}
F0R(i,n) {
if(r[i]>1) {
rc.pb({r[i],c[i]});
}
}
rc.pb({1ll,1ll});
sort(all(rc));
ll cnt=0;
F0R(i,rc.size()-1) {
ll d1 = rc[i].f-rc[i].s;
ll d2 = rc[i+1].f-rc[i+1].s;
assert(d1<=d2);
ll k = d2-d1;
if(!(d1%2)) {
if(k==0) {
cnt+=rc[i+1].f-rc[i].f;
} else {
cnt+=(k/2);
}
} else {
cnt+=(k+1)/2;
}
}
cout<<cnt<<nl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(20);
cout << fixed;
int T = 1;
cin >> T;
F0R(i,T) {
solve(i+1);
}
}
// read the question correctly (ll vs int)
// template by bqi343 |
// Problem: F. Triangular Paths
// Contest: Codeforces - Codeforces Round #710 (Div. 3)
// URL: https://codeforces.com/contest/1506/problem/F
// Memory Limit: 256 MB
// Time Limit: 2000 ms
//
// Powered by CP Editor (https://cpeditor.org)
#include <bits/stdc++.h>
#define pb push_back
#define eb emplace_back
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
const int N = 2e5 + 10;
pair<int, int> a[N];
void solve() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i].first;
}
for (int i = 1; i <= n; ++i) {
cin >> a[i].second;
}
sort(a + 1, a + 1 + n);
int nowx = 1, nowy = 1;
ll ans = 0;
for (int i = 1; i <= n; ++i) {
int x = a[i].first, y = a[i].second;
if (nowx == x && nowy == y) continue;
int d = x - y;
int nowd = nowx - nowy;
if (d == nowd) {
if ((x + y) % 2 == 0) {
ans += x - nowx;
}
} else {
if ((nowx + nowy) % 2 == 0) {
if ((x + y) % 2 == 0) {
ans += (d - nowd) / 2;
} else {
ans += (d - nowd) / 2;
}
} else {
if ((x + y) % 2 == 0) {
ans += (d - nowd + 1) / 2;
} else {
ans += (d - nowd) / 2;
}
}
}
nowx = x;
nowy = y;
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
int T = 1;
cin >> T;
// scanf("%d", &T);
while (T--) {
solve();
}
return 0;
} |
#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <complex>
#include <functional>
using namespace std;
#define ll long long
inline long long read(){
long long x = 0; int zf = 1; char ch = ' ';
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') zf = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar(); return x * zf;
}
#define ll long long
#define MOD 1000000007
using namespace std;
struct Node {
ll r;
ll c;
};
Node node[200005];
void solve() {
ll n = read();
for(int i=0; i<n; i++) node[i].r = read();
for(int i=0; i<n; i++) node[i].c = read();
sort(node, node+n, [](const Node&lhs, const Node&rhs){
return lhs.r < rhs.r;
});
ll r = 1;
ll c = 1;
ll res = 0;
for(int i=0; i<n; i++) {
ll tr = node[i].r;
ll tc = node[i].c;
if(tr==r) {
continue;
}
ll delta_r = tr - r;
ll delta_c = tc - c;
if (delta_c==delta_r) {
if ((r+c) % 2 == 0){
res += delta_r;
}
} else {
int gap = delta_r - delta_c;
if ((r+c) % 2 == 0) {
res += gap / 2;
} else {
res += (gap+1) / 2;
}
}
r = tr;
c = tc;
}
cout << res << endl;
}
int main() {
ll t = read();
while(t--) {
solve();
}
// solve();
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
struct node{
int r,c,d;
}a[200010];
int t,n,ans=0;
bool cmp(node a,node b){
return a.r<b.r;
}
int main(){
scanf("%d",&t);
while(t--){
ans=0;
scanf("%d",&n);a[0]={1,1,0};
for(int i=1;i<=n;i++)scanf("%d",&a[i].r);
for(int i=1;i<=n;i++){
scanf("%d",&a[i].c);
a[i].d=a[i].r-a[i].c;
}
sort(a+1,a+n+1,cmp);
for(int i=1;i<=n;i++){
if(a[i].d==a[i-1].d){
if(a[i].d%2==0)ans+=a[i].c-a[i-1].c;
}
else{
if(a[i-1].d%2==0)ans+=(a[i].d-a[i-1].d)/2;
else ans+=(a[i].d-a[i-1].d+1)/2;
}
}
printf("%d\n",ans);
}
} |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define all(x) x.begin(), x.end()
#define pb push_back
#define mp make_pair
#define ps push
#define in insert
#define f first
#define s second
#define ca(v) for(auto i:v) cout<<i<<" ";
#define cp(v) for(auto i:v) cout<<i.f<<" "<<i.s<<"\n";
#define nl cout<<"\n"
#define cbit(x) __builtin_popcount(x)
#define gcd(a, b) __gcd(a, b)
#define lcm(a, b) (a*b/gcd(a, b))
#define CAR(ar, n) int ar[n]; for(int i=0; i<n; i++) cin>>ar[i];
#define ADJ(m, n) vector<int> adj[n]; for(int i=0; i<m; i++) { int u, v; cin>>u>>v; adj[--u].pb(--v); adj[v].pb(u); }
#define ADS(n, m) set<int> adj[n]; for(int i=0; i<m; i++) { int u, v; cin>>u>>v; adj[--u].in(--v); adj[v].in(u); }
int xm[4] = {-1, 1, 0, 0};
int ym[4] = {0, 0, -1, 1};
const int MOD = 1e9 + 7;
const int MAXN = 5e5 + 5;
const ll POW = 9973;
int main()
{
ios_base::sync_with_stdio(0); cin.tie(0);
int t;
cin>>t;
while(t--){
int n; cin>>n;
vector<pair<int, int>> v;
ll ar[n+1][2];
for(int j=0; j<2; j++)
for(int i=0; i<n; i++) cin>>ar[i][j];
for(int i=0; i<n; i++){
v.pb({ar[i][0], ar[i][1]});
}
sort(all(v));
for(int i=1; i<=n; i++){
ar[i][0] = v[i-1].f;
ar[i][1] = v[i-1].s;
}
ar[0][0] = ar[0][1] = 1;
ll ans = 0;
for(int i=1; i<=n; i++){
int j = i-1;
ll df1 = ar[j][0] - ar[j][1];
ll df2 = ar[i][0] - ar[i][1];
if(df1 == df2){
if(df1 % 2 == 0) ans += ar[i][0] - ar[j][0];
}
else{
if(df1 % 2 == 0) ans += (df2 - df1)/2;
else ans += (df2 - df1 + 1)/2;
}
}
cout<<ans<<"\n";
}
}
|
//Created by: Aditya Singh
//Bleed Blue
#include <bits/stdc++.h>
using namespace std;
// #pragma GCC optimize("O3")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,avx,avx2")
#define int long long int
#define ld long double
#define F first
#define S second
#define P pair<int,int>
#define unm map<int,int>
#define pb emplace_back
#define PI 3.1415926535897932384626433
#define inf 1e18
const int N = 200005;
P ar[N];
int dist(int r1, int c1, int r2, int c2) {
if (r1 - c1 == r2 - c2)
return (r1 + c1) & 1 ? 0 : r2 - r1;
r2 -= r1 - 1, c2 -= c1 - 1;
return (r1 + c1) & 1 ^ 1 ? (r2 - c2) / 2 : (r2 - c2 + 1) / 2;
}
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
int t; cin >> t; while (t--)
{
int i, j, k, n, m, ans = 0, cnt = 0, sum = 0;
cin >> n;
for (i = 0; i < n; i++)
cin >> ar[i].F;
for (i = 0; i < n; i++)
cin >> ar[i].S;
sort(ar, ar + n);
int a = 1, b = 1;
for (i = 0; i < n; i++) {
ans += dist(a, b, ar[i].F, ar[i].S);
a = ar[i].F, b = ar[i].S;
}
cout << ans << '\n';
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll t = 1,n,m,c,u,v,x,y,z;
string s;
struct st{ll x,y;}p[200009];
bool cmp(const st &a,const st &b){return a.x < b.x;}
int main(){cin>>t;
while (t --){
cin>>n; ll ans = 0;
for (ll i = 1;i <= n;i += 1) cin>>p[i].x;
for (ll i = 1;i <= n;i += 1) cin>>p[i].y;
sort(p + 1,p + n + 1,cmp); p[0].x = 1;
ll pre = 0;
for (ll i = 1;i <= n;i += 1){
ll qwq = p[i].x - p[i].y;
if (qwq / 2 != pre / 2) ans += qwq / 2 - pre / 2;
else if (pre % 2 == 0 && qwq % 2 == 0) ans += p[i].x - p[i - 1].x;
//cout<<ans<<endl;
pre = qwq;
}
cout<<ans<<endl;
}
return 0;
} |
#include <bits/stdc++.h>
#define forr(i,a,b) for(int i=(a);i<(b);i++)
#define forn(i,n) forr(i,0,n)
#define dforn(i,n) for(int i=n-1;i>=0;i--)
#define forall(it,v) for(auto it=v.begin();it!=v.end();it++)
#define sz(c) ((int)c.size())
#define rsz resize
#define pb push_back
#define mp make_pair
#define lb lower_bound
#define ub upper_bound
#define fst first
#define snd second
#ifdef ANARAP
//prueba
#else
//real
#endif
using namespace std;
typedef long long ll;
typedef pair<int,int> ii;
int main()
{
#ifdef ANARAP
freopen("input.in", "r", stdin);
//freopen("output.out", "w", stdout);
unsigned t0, t1; t0=clock();
#endif
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t; cin >> t;
forn(T,t){
int n; cin >> n;
vector<ii> a(n+1);
a[0].fst = 1;
a[0].snd=1;
forn(i,n) cin >> a[i+1].fst;
forn(i,n) cin >> a[i+1].snd;
sort(a.begin(), a.end());
ll ans = 0;
forn(i,n){
int actual = a[i].fst+a[i].snd;
ll difx = a[i+1].fst-a[i].fst;
ll dify = a[i+1].snd-a[i].snd;
if(dify == difx){
if(actual%2 == 0) ans+=difx;
}
else{
int dif = abs(difx-dify);
if(actual%2)ans+=(dif+1)/2;
else{
a[i].fst++;
actual++;
difx = a[i+1].fst-a[i].fst;
dify = a[i+1].snd-a[i].snd;
if(dify == difx){
if(actual%2 == 0) ans+=difx;
}
else{
int dif = abs(difx-dify);
if(actual%2)ans+=(dif+1)/2;
}
}
}
}
cout << ans << '\n';
}
#ifdef ANARAP
t1 = clock();double time = (double(t1-t0)/CLOCKS_PER_SEC); cout << "Execution Time: " << time << endl;
#endif
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define M 1000000007
#define po int tc; cin>>tc; while(tc--)
#define endl "\n"
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
cout << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ','); cout.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
#else
#define trace(...)
#endif
void get_schwifty() {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
bool is_odd(int r, int c) {
return (r+c)%2 == 1;
}
int calc_dis(int r1, int c1, int r2, int c2) {
if(r1-c1 == r2-c2)
return is_odd(r1, c1) ? 0 : r2 - r1;
r2 -= r1-1;
c2 -= c1-1;
if(is_odd(r1, c1))
return (r2-c2+1)/2;
else
return (r2-c2)/2;
}
void solve() {
int n;
cin>>n;
vector<pair<int, int>> points(n);
for(int i=0; i<n; i++)
cin>>points[i].first;
for(int i=0; i<n; i++)
cin>>points[i].second;
sort(points.begin(), points.end(), [](pair<int, int> a, pair<int, int> b) -> bool{
return a.first < b.first;
});
int ans = 0;
int curr_r = 1, curr_c = 1;
for(auto[next_r, next_c] : points) {
ans += calc_dis(curr_r, curr_c, next_r, next_c);
curr_r = next_r;
curr_c = next_c;
}
cout<<ans<<endl;
}
int32_t main()
{
get_schwifty();
po {
solve();
}
return 0;
} |
#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<math.h>
#include<stack>
#include<queue>
#include<map>
#include<set>
#define ll long long
#define gcd(a,b) __gcd(a,b)
#define lcm(a,b) a*b/(__gcd(a,b))
#define rep(i,s,e) for(int i=s;i<e;i++)
#define fep(i,s,e) for(int i=s;i<=e;i++)
#define mem(a,n) memset(a, n ,sizeof(a))
#define Fill(a,n,b) fill(a,a+n,b)
#define IOS ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
using namespace std;
//priority_queue <int,vector<int>,less<int> > Q;
const int eps = 1e-7;
const int inf= 0x3f3f3f3f;
const int N = 1e5+5;
pair<int,int> p[2*N];
void solve(){
int n;
cin >> n ;
for(int i=1;i<=n;i++) cin >> p[i].first;
for(int i=1;i<=n;i++) cin >> p[i].second;
sort(p+1,p+1+n);
p[0].first = 1;
p[0].second = 1;
int res = 0;
for(int i=1;i<=n;i++){
int a = p[i-1].first - p[i-1].second;
int b = p[i].first - p[i].second;
if(a == b){
if(a % 2 == 0){
res+=p[i].second - p[i-1].second;
}
} else{
res+=(b/2-a/2);
}
}
printf("%d\n",res);
}
int main(){
IOS;
int t;
cin >> t;
while(t--){
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std ;
const int MAX = 2e5 + 10 ;
int a[MAX] , b[MAX] ;
int n ;
vector< pair<int , int> >vp ;
int calc(pair<int , int>p1 , pair<int , int>p2)
{
int r1 = p1.first , r2 = p2.first ;
int c1 = p1.second , c2 = p2.second ;
if(r2 - r1 == c2 - c1)
{
if((r1 + c1) % 2 == 0)
return (r2 - r1) ;
else
return 0 ;
}
if((r1 + c1) % 2 == 0)
r1++ ;
int diff = (r2 - r1) - (c2 - c1) ;
return ((diff + 1) / 2) ;
}
int main()
{
ios_base::sync_with_stdio(0) ;
cin.tie(0) ;
int t ;
cin>>t ;
while(t--)
{
vp.clear() ;
cin>>n ;
for(int i = 0 ; i < n ; ++i)
cin>>a[i] ;
for(int i = 0 ; i < n ; ++i)
cin>>b[i] ;
for(int i = 0 ; i < n ; ++i)
vp.emplace_back(a[i] , b[i]) ;
sort(vp.begin() , vp.end()) ;
int ans = 0 ;
pair<int , int>p1 = {1 , 1} ;
for(auto &p2 : vp)
{
ans += calc(p1 , p2) ;
p1 = p2 ;
}
cout<<ans<<"\n" ;
}
return 0 ;
} |
#include <bits/stdc++.h>
using namespace std;
bool isLeftArrow(int r, int c) {
return (r + c) % 2 == 0;
}
bool isRightArrow(int r, int c) {
return (r + c) % 2 == 1;
}
int calcDist(int r1, int c1, int r2, int c2) {
if (r1 - c1 == r2 - c2) {
return isRightArrow(r1, c1) ? 0 : r2 - r1;
}
r2 -= r1 - 1;
c2 -= c1 - 1;
if (isLeftArrow(r1, c1)) {
return (r2 - c2) / 2;
} else {
return (r2 - c2 + 1) / 2;
}
}
void solve() {
int n;
cin >> n;
vector<int> r(n);
vector<int> c(n);
for (int i = 0; i < n; i++) {
cin >> r[i];
}
for (int i = 0; i < n; i++) {
cin >> c[i];
}
vector<pair<int, int>> pts;
for (int i = 0; i < n; i++) {
pts.emplace_back(r[i], c[i]);
}
sort(pts.begin(), pts.end());
int curR = 1, curC = 1;
int res = 0;
for (auto[nextR, nextC] : pts) {
res += calcDist(curR, curC, nextR, nextC);
curR = nextR;
curC = nextC;
}
cout << res << "\n";
}
int main() {
int tests;
cin >> tests;
while (tests-- > 0) {
solve();
}
return 0;
} |
#pragma GCC optimize("O3")
#include<bits/stdc++.h>
using namespace std;
using ll=unsigned long long;
using P=pair<ll,ll>;
template<class T> using V=vector<T>;
#define fi first
#define se second
#define all(v) (v).begin(),(v).end()
const ll inf=(1e18);
//const ll mod=998244353;
const ll mod=1000000007;
const vector<int> dy={-1,0,1,0},dx={0,-1,0,1};
ll GCD(ll a,ll b) {return b ? GCD(b,a%b):a;}
ll LCM(ll c,ll d){return c/GCD(c,d)*d;}
struct __INIT{__INIT(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(20);}} __init;
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
template<class T>void debag(const vector<T> &a){cerr<<"debag :";for(auto v:a)cerr<<v<<" ";cerr<<"\n";}
template<class T>void print(const vector<T> &a){for(auto v:a)cout<<v<<" ";cout<<"\n";}
void solve(){
int n;
cin>>n;
V<int> r(n),c(n);
for(int i=0;i<n;i++)cin>>r[i];
for(int i=0;i<n;i++)cin>>c[i];
V<P> d(n);
for(int i=0;i<n;i++)d[i]=P(r[i],c[i]);
sort(all(d));
reverse(all(d));
if(d.back()!=P(1,1))d.emplace_back(1,1);
reverse(all(d));
int m=d.size();
ll ans=0;
for(int i=0;i<m-1;i++){
ll a=d[i+1].fi-d[i].fi,b=d[i+1].se-d[i].se;
bool flag=((d[i].fi+d[i].se)%2==0);
if(a==b){
if(flag)ans+=a;
continue;
}
if(flag)a--;
if(a>b)ans+=(a-b+1)/2;
else if(b<a)exit(1);
}
cout<<ans<<"\n";
}
int main(){
int t=1;
cin>>t;
while(t--)solve();
} |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
long path(long r1, long r, long c1, long c) {
if((r1+c1) % 2) {
return (r-c+1) / 2;
}
else if(r == c) {
return r-1;
}
return (r-c)/2;
}
void solve() {
int n;
cin >> n;
long r, c, r1, c1;
long long p = 0;
vector<pair<long, long>> rcs(n);
int i = 0;
while(i < n) {
cin >> rcs[i].first;
i ++;
}
i = 0;
while(i < n) {
cin >> rcs[i].second;
i ++;
}
std::sort(rcs.begin(), rcs.end(),
[](pair<long, long> const &a, pair<long, long> const &b) {
return a.first < b.first;
});
r1 = 1;
c1 = 1;
for (int j = 0; j < n; ++j) {
r = rcs[j].first;
c = rcs[j].second;
if(!(r1 == r && c1 == c)) {
p += path(r1, r - r1 + 1, c1, c - c1 + 1);
}
r1 = r;
c1 = c;
}
cout << p << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
} |
#include <iostream>
#include <algorithm>
#include <utility>
#include <vector>
using namespace std;
#define MAXN 200200
#define ll long long
int t, n, r[MAXN];
vector<pair<int,int> > pts;
ll cost(pair<int,int> a, pair<int,int> b) {
if (b.first - a.first == b.second - a.second)
return ((a.first + a.second) % 2) ? 0 : (b.first - a.first);
return ((b.first - a.first) - (b.second - a.second) + ((a.first + a.second) % 2)) / 2;
}
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
pts.push_back(make_pair(1,1));
for (int i = 0; i < n; i++) scanf("%d", &r[i]);
for (int i = 0; i < n; i++) {
int c; scanf("%d", &c);
pts.push_back(make_pair(r[i], c));
}
sort(pts.begin(), pts.end());
ll ans = 0;
for (int i = 1; i <= n; i++) {
ans += cost(pts[i-1], pts[i]);
}
printf("%lld\n", ans);
pts.clear();
}
} |
#include<bits/stdc++.h>
#include<vector>
using namespace std;
#define ll long long int
#define mod 1000000007
#define fo(i,l,r) for(i=l;i<=r;i++)
#define decimal(i) setprecision(i)
ll calc(int r1, int c1, int r2, int c2){
ll cost = 0;
if(r1==r2 && c1==c2){
return 0;
}
if((r2-c2)%2){
return (r2-c2-r1+c1)/2;
}
else{
if(r2-c2>r1-c1){
return 1+(r2-c2-r1+c1-1)/2;
}
else{
return r2-r1;
}
}
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T,tt;
cin >> T;
fo(tt, 0, T-1){
int n;
cin >> n;
int r[n],c[n];
for(int i=0;i<n;i++){
cin >> r[i];
}
vector<pair<int, int> > p;
for(int i=0;i<n;i++){
cin >> c[i];
p.push_back(make_pair(r[i], c[i]));
}
sort(p.begin(), p.end());
ll cost = calc(1, 1, p[0].first, p[0].second);
for(int i=1;i<n;i++){
cost += calc(p[i-1].first, p[i-1].second, p[i].first, p[i].second);
}
cout << cost << endl;
}
return 0;
}
|
/**
* author: ivanzuki
* created: Thu Mar 25 2021
**/
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int tt;
cin >> tt;
while (tt--) {
int n;
cin >> n;
vector<pair<int, int>> p(n);
for (int i = 0; i < n; i++) {
cin >> p[i].first;
}
for (int i = 0; i < n; i++) {
cin >> p[i].second;
}
sort(p.begin(), p.end());
reverse(p.begin(), p.end());
if (p.back() != make_pair(1, 1)) {
p.push_back(make_pair(1, 1));
}
reverse(p.begin(), p.end());
int ans = 0;
for (int i = 0; i + 1 < (int) p.size(); i++) {
int from_r = p[i].first, from_c = p[i].second;
int to_r = p[i + 1].first, to_c = p[i + 1].second;
if (to_r - from_r == to_c - from_c) {
int cost = (from_r + from_c) % 2 == 0 ? to_c - from_c : 0;
ans += cost;
} else if ((to_r + to_c) % 2 == 1) {
int d = to_c - from_c;
int mid_r = to_r - d;
int mid_c = to_c - d;
int cost = 0;
if ((from_r + from_c) % 2 == 0) {
cost = (mid_r - from_r) / 2;
} else {
cost = (mid_r - from_r + 1) / 2;
}
ans += cost;
} else {
int d = to_c - from_c;
int mid_r = to_r - 1 - d;
int mid_c = to_c - d;
int cost = 1;
if ((from_r + from_c) % 2 == 0) {
cost += (mid_r - from_r) / 2;
} else {
cost += (mid_r - from_r + 1) / 2;
}
ans += cost;
}
}
cout << ans << '\n';
}
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[111][111];
int n, m, k;
vector<pair<int, int> > pos;
int ddist[111][111], way[10][10], dist[211][10];
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};
queue<pair<int, int> > que;
void bfs(int x, int y, int o) {
int i, j, u, v;
while (!que.empty()) que.pop();
que.push(make_pair(x, y));
for (i = 0; i <= n + 1; i++)
for (j = 0; j <= m + 1; j++) ddist[i][j] = -1;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) ddist[i][j] = MOD;
ddist[x][y] = val[x][y];
dp[(x - 1) * m + y][1 << o] = val[x][y];
while (!que.empty()) {
u = que.front().first, v = que.front().second;
que.pop();
for (i = 0; i < 4; i++) {
x = u + dx[i];
y = v + dy[i];
if (ddist[x][y] == -1) continue;
if (ddist[x][y] > ddist[u][v] + val[x][y]) {
ddist[x][y] = ddist[u][v] + val[x][y];
dp[(x - 1) * m + y][1 << o] = ddist[x][y];
pre[(x - 1) * m + y][1 << o] = make_pair((u - 1) * m + v, 1 << o);
que.push(make_pair(x, y));
}
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
dist[(i - 1) * m + j][o] = ddist[i][j];
}
}
}
set<pair<int, 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++) {
scanf("%d", &val[i][j]);
}
}
pos.clear();
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;
}
}
}
for (i = 0; i < k; i++) {
scanf("%d%d", &u, &v);
pos.push_back(make_pair(u, v));
dp[(u - 1) * m + v][1 << i] = val[u][v];
}
S[0].clear();
S[1].clear();
for (i = 0; i < k; i++) S[0].insert(make_pair(pos[i].first, pos[i].second));
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()) {
u = S[uu].begin()->first;
v = S[uu].begin()->second;
S[uu].erase(S[uu].begin());
p = (u - 1) * m + v;
for (i = 0; i < 4; i++) {
x = u + dx[i];
y = v + dy[i];
if (x < 1 || x > n || y < 1 || y > m) continue;
q = (x - 1) * m + y;
for (l = 0; l < (1 << k); l++) {
if (dp[q][l] > dp[p][l] + val[x][y]) {
dp[q][l] = dp[p][l] + val[x][y];
pre[q][l] = make_pair(p, l);
S[vv].insert(make_pair(x, y));
}
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(make_pair(x, y));
}
}
}
}
}
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;
template <typename T>
inline void chkmin(T &x, T y) {
if (y < x) x = y;
}
template <typename T>
inline void chkmax(T &x, T y) {
if (y > x) x = y;
}
template <typename T>
inline T add(T x, T y) {
return (x + y) % 1000000007;
}
template <typename T>
inline T mul(T x, T y) {
return 1LL * x * y % 1000000007;
}
template <typename T>
inline T qp(T x, T n) {
T ans = 1;
do {
if (n & 1) ans = mul(ans, x);
x = mul(x, x);
} while (n >>= 1);
return ans;
}
const int SZ = 1 << 13;
char buff[SZ], *pos = buff + SZ - 1;
inline long long read() {
long long x = 0;
int f = 1,
c = (++pos == buff + SZ ? fread(pos = buff, 1, SZ, stdin), *pos : *pos);
for (; !isdigit(c);
c = (++pos == buff + SZ ? fread(pos = buff, 1, SZ, stdin), *pos : *pos))
if (c == '-') f = -f;
for (; isdigit(c);
c = (++pos == buff + SZ ? fread(pos = buff, 1, SZ, stdin), *pos : *pos))
x = (x << 3) + (x << 1) + (c ^ 48);
return x * f;
}
int n, m;
int k;
int a[105][105];
int dis[205][205];
int prvv[205][205];
int dp[205][1 << 7];
pair<pair<int, int>, pair<pair<int, int>, pair<int, int> > > prv[205][1 << 7];
int xx[15], yy[15];
char anss[105][105];
void print_path(int sx, int sy, int ex, int ey) {
while (ex != sx || ey != sy) {
anss[ex][ey] = 'X';
int xxx = prvv[sx * m + sy][ex * m + ey];
ex = xxx / m, ey = xxx % m;
}
anss[ex][ey] = 'X';
}
void printans(int xy, int msk) {
int x = xy / m, y = xy % m;
if (__builtin_popcount(msk) == 1) {
int lst = __builtin_ctz(msk);
print_path(x, y, xx[lst], yy[lst]);
return;
}
print_path(prv[xy][msk].second.first.first, prv[xy][msk].second.first.second,
prv[xy][msk].second.second.first,
prv[xy][msk].second.second.second);
printans(
prv[xy][msk].second.first.first * m + prv[xy][msk].second.first.second,
prv[xy][msk].first.first);
printans(
prv[xy][msk].second.second.first * m + prv[xy][msk].second.second.second,
prv[xy][msk].first.second);
}
const int dx[] = {0, 0, -1, 1};
const int dy[] = {-1, 1, 0, 0};
int main() {
n = read(), m = read(), k = read();
for (int i = 0; i < (int)(n); ++i)
for (int j = 0; j < (int)(m); ++j) a[i][j] = read();
for (int i = 0; i < (int)(k); ++i) xx[i] = read() - 1, yy[i] = read() - 1;
memset(dis, 0x3f, sizeof dis);
for (int sx = 0; sx < (int)(n); ++sx)
for (int sy = 0; sy < (int)(m); ++sy) {
priority_queue<pair<int, pair<int, int> >,
vector<pair<int, pair<int, int> > >,
greater<pair<int, pair<int, int> > > >
pq;
pq.push(make_pair(a[sx][sy], make_pair(sx, sy)));
dis[sx * m + sy][sx * m + sy] = a[sx][sy];
while (!pq.empty()) {
pair<int, pair<int, int> > p = pq.top();
pq.pop();
int x = p.second.first, y = p.second.second;
for (int i = 0; i < (int)(4); ++i) {
int nx = x + dx[i], ny = y + dy[i];
if (nx < 0 || ny < 0 || nx >= n || ny >= m) continue;
if (dis[sx * m + sy][nx * m + ny] >
dis[sx * m + sy][x * m + y] + a[nx][ny]) {
dis[sx * m + sy][nx * m + ny] =
dis[sx * m + sy][x * m + y] + a[nx][ny];
prvv[sx * m + sy][nx * m + ny] = x * m + y;
pq.push(
make_pair(dis[sx * m + sy][nx * m + ny], make_pair(nx, ny)));
}
}
}
}
memset(dp, 0x3f, sizeof dp);
for (int ij = 0; ij < (int)(n * m); ++ij)
for (int l = 0; l < (int)(k); ++l)
dp[ij][1 << l] = dis[ij][xx[l] * m + yy[l]];
for (int msk = 0; msk < (int)(1 << k); ++msk)
if (__builtin_popcount(msk) > 1) {
for (int i = 0; i < (int)(n * m); ++i) {
for (int msk1 = (msk - 1) & msk; msk1; msk1 = (msk1 - 1) & msk) {
int msk2 = msk ^ msk1;
for (int j = 0; j < (int)(n * m); ++j) {
if (dp[i][msk] > dp[i][msk1] + dp[j][msk2] + dis[i][j] -
a[i / m][i % m] - a[j / m][j % m]) {
dp[i][msk] = dp[i][msk1] + dp[j][msk2] + dis[i][j] -
a[i / m][i % m] - a[j / m][j % m];
prv[i][msk] = make_pair(
make_pair(msk1, msk2),
make_pair(make_pair(i / m, i % m), make_pair(j / m, j % m)));
}
if (dp[i][msk] > dp[j][msk1] + dp[i][msk2] + dis[i][j] -
a[i / m][i % m] - a[j / m][j % m]) {
dp[i][msk] = dp[j][msk1] + dp[i][msk2] + dis[i][j] -
a[i / m][i % m] - a[j / m][j % m];
prv[i][msk] = make_pair(
make_pair(msk1, msk2),
make_pair(make_pair(j / m, j % m), make_pair(i / m, i % m)));
}
}
}
}
}
int ans = 1e9;
int ansxy;
for (int i = 0; i < (int)(n * m); ++i)
if (dp[i][(1 << k) - 1] < ans) ans = dp[i][(1 << k) - 1], ansxy = i;
for (int i = 0; i < (int)(n); ++i)
for (int j = 0; j < (int)(m); ++j) anss[i][j] = '.';
printf("%d\n", ans);
printans(ansxy, (1 << k) - 1);
for (int i = 0; i < (int)(n); ++i)
for (int j = 0; j < (int)(m); ++j) {
printf("%c", anss[i][j]);
if (j + 1 == m) puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mm[4][2] = {0, 1, 0, -1, 1, 0, -1, 0};
int a[205], n, m, k, data[7];
int dp[1 << 7][205], from[1 << 7][205][3], g[205][205], h[205][205];
bool mark[205];
bool check(int &x, int y) {
if (x == 0 || x > y) {
x = y;
return true;
}
return false;
}
void dfs(int x, int y) {
if (h[x][y] == 0)
mark[x] = mark[y] = true;
else {
dfs(x, h[x][y]);
dfs(h[x][y], y);
}
}
void solve(int i, int k) {
if (from[i][k][0] == 0) {
solve(from[i][k][1], k);
solve(from[i][k][2], k);
} else if (from[i][k][0] == 1) {
dfs(from[i][k][1], k);
solve(i, from[i][k][1]);
} else
dfs(from[i][k][1], from[i][k][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 * m + j]);
for (int i = 0; i < k; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
data[i] = x * m + y;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int k = 0; k < 4; k++) {
int x = i + mm[k][0], y = j + mm[k][1];
if (x < 0 || x == n || y < 0 || y == m) continue;
g[i * m + j][x * m + y] = a[i * m + j] + a[x * m + y];
}
for (int i = 0; i < n * m; i++) g[i][i] = a[i];
for (int kk = 0; kk < n * m; kk++)
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++) {
if (i == j || g[i][kk] == 0 || g[kk][j] == 0) continue;
if (g[i][j] == 0 || g[i][j] > g[i][kk] + g[kk][j] - a[kk]) {
g[i][j] = g[i][kk] + g[kk][j] - a[kk];
h[i][j] = kk;
}
}
for (int i = 0; i < k; i++)
for (int j = 0; j < n * m; j++) {
dp[(1 << i)][j] = g[data[i]][j];
from[1 << i][j][0] = -1;
from[1 << i][j][1] = data[i];
from[1 << i][j][2] = j;
}
for (int i = 1; i < (1 << k); i++) {
for (int k = 0; k < n * m; k++) {
for (int j = 1; j < i; j++) {
if ((i | j) != i) continue;
if (check(dp[i][k], dp[j][k] + dp[i ^ j][k] - a[k])) {
from[i][k][0] = 0;
from[i][k][1] = j;
from[i][k][2] = i ^ j;
}
}
for (int k1 = 0; k1 < n * m; k1++)
if (check(dp[i][k1], dp[i][k] + g[k][k1] - a[k])) {
from[i][k1][0] = 1;
from[i][k1][1] = k;
}
}
}
int w = 0;
for (int i = 0; i < n * m; i++)
if (dp[(1 << k) - 1][i] < dp[(1 << k) - 1][w]) w = i;
printf("%d\n", dp[(1 << k) - 1][w]);
solve((1 << k) - 1, w);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (mark[i * m + j])
printf("X");
else
printf(".");
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
int add(int a, int b) {
if ((a += b) >= P) a -= P;
return a;
}
int sub(int a, int b) {
if ((a -= b) < 0) a += P;
return a;
}
int mul(int a, int b) { return 1ll * a * b % P; }
int kpow(int a, int b) {
int r = 1;
for (; b; b >>= 1, a = mul(a, a)) {
if (b & 1) r = mul(r, a);
}
return r;
}
const int N = 105;
int n, m, k, a[N][N], st[N][N], dp[N][N][300], vis[N][N][300], u, v, S, y, x,
ans, use[N][N];
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
pair<pair<pair<int, int>, int>, int> fa[N][N][300];
queue<pair<int, int> > q;
pair<pair<int, int>, int> now;
void spfa(int mask) {
while (!q.empty()) {
pair<int, int> u = q.front();
q.pop();
vis[u.first][u.second][mask] = 0;
for (int i = (0); i < (4); i++) {
int x = u.first + dx[i], y = u.second + dy[i];
if (x > n || x < 1 || y > m || y < 1) continue;
int &z = dp[x][y][mask | st[x][y]];
if (z == -1 || z > dp[u.first][u.second][mask] + a[x][y]) {
z = dp[u.first][u.second][mask] + a[x][y];
fa[x][y][mask | st[x][y]] = make_pair(make_pair(u, mask), -1);
if ((st[x][y] | mask != mask) || vis[x][y][mask]) continue;
vis[x][y][mask] = 1;
q.push(make_pair(x, y));
}
}
}
}
void dfs(pair<pair<int, int>, int> now) {
auto t = fa[now.first.first][now.first.second][now.second];
int x = t.first.first.first, y = t.first.first.second;
int m1 = t.first.second, m2 = t.second;
if (x == 0) {
use[now.first.first][now.first.second] = 1;
return;
}
dfs(make_pair(make_pair(x, y), m1));
if (m2 == -1) {
use[now.first.first][now.first.second] = 1;
} else
dfs(make_pair(make_pair(x, y), m2));
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cin >> n >> m >> k;
for (int i = (1); i < (n + 1); i++)
for (int j = (1); j < (m + 1); j++) cin >> a[i][j];
memset(dp, -1, sizeof(dp));
for (int i = (0); i < (k); i++) {
cin >> u >> v;
st[u][v] = (1ll << (i));
dp[u][v][(1ll << (i))] = a[u][v];
}
S = (1ll << (k));
for (int mask = (1); mask < (S); mask++) {
for (int i = (1); i < (n + 1); i++)
for (int j = (1); j < (m + 1); j++) {
if (st[i][j] && !(st[i][j] & mask)) continue;
int &z = dp[i][j][mask];
for (int t = mask & (mask - 1); t > 0; t = (t - 1) & mask) {
int &x = dp[i][j][t | st[i][j]], &y = dp[i][j][mask ^ t | st[i][j]];
if (x != -1 && y != -1) {
if (z == -1 || z > x + y - a[i][j]) {
z = x + y - a[i][j];
fa[i][j][mask] =
make_pair(make_pair(make_pair(i, j), t | st[i][j]),
mask ^ t | st[i][j]);
}
}
}
if (z != -1) q.push(make_pair(i, j)), vis[i][j][mask] = 1;
}
spfa(mask);
}
ans = (1ll << (30));
for (int i = (1); i < (n + 1); i++)
for (int j = (1); j < (m + 1); j++)
if (dp[i][j][S - 1] != -1 && ans > dp[i][j][S - 1])
ans = dp[i][j][S - 1], now = make_pair(make_pair(i, j), S - 1);
cout << ans << "\n";
dfs(now);
for (int i = (1); i < (n + 1); i++) {
for (int j = (1); j < (m + 1); j++)
if (use[i][j])
cout << "X";
else
cout << ".";
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000007;
vector<int> e[200];
int n, m, w, a[200], u[100];
int dp[200][128];
pair<int, int> pt[200][128];
char o[105][105];
void add_edge(int t, int p, int q) {
if (p < 0 || q < 0 || p >= n || q >= m) return;
e[t].push_back(p * m + q);
}
void getans(int x, int s) {
if (x < 0) return;
o[x / m][x % m] = 'X';
int y, p;
tie(y, p) = pt[x][s];
getans(y, p);
if (p != s && p >= 0) getans(y, p ^ s);
}
int main() {
scanf("%d%d%d", &n, &m, &w);
memset(dp, 63, sizeof(dp));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int t = i * m + j;
scanf("%d", a + t);
o[i][j] = '.';
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int t = i * m + j;
add_edge(t, i - 1, j);
add_edge(t, i + 1, j);
add_edge(t, i, j - 1);
add_edge(t, i, j + 1);
}
for (int i = 0; i < w; i++) {
int r, c;
scanf("%d%d", &r, &c);
u[i] = (r - 1) * m + c - 1;
dp[u[i]][1 << i] = a[u[i]];
pt[u[i]][1 << i] = {-1, -1};
}
int mask = (1 << w) - 1, nm = n * m;
for (int s = 1; s <= mask; s++) {
for (int x = 0; x < nm; x++)
for (int p = (s - 1) & s; p; p = (p - 1) & s) {
int q = s ^ p, use = dp[x][p] + dp[x][q] - a[x];
if (use < dp[x][s]) {
dp[x][s] = use;
pt[x][s] = {x, p};
}
}
queue<int> q;
bool in[200];
for (int x = 0; x < nm; in[x++] = true) q.push(x);
while (q.size()) {
int x = q.front();
q.pop();
in[x] = false;
for (auto y : e[x]) {
int use = dp[x][s] + a[y];
if (use < dp[y][s]) {
dp[y][s] = use;
pt[y][s] = {x, s};
if (!in[y]) {
in[y] = true;
q.push(y);
}
}
}
}
}
int v = 0;
for (int i = 0; i < nm; i++)
if (dp[i][mask] < dp[v][mask]) v = i;
printf("%d\n", dp[v][mask]);
getans(v, mask);
for (int i = 0; i < n; i++) puts(o[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
inline int read() {
int X = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
return w ? -X : X;
}
struct node {
int msk, x, y;
node() {}
node(int _mask, int _x, int _y) {
msk = _mask;
x = _x;
y = _y;
}
};
node pre[505][105][105];
queue<node> q;
int n, m, k;
int dat[105][105];
int dp[505][105][105];
bool use[105][105];
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
bool hav[505][105][105];
void printmsk(int msk) {
string s;
while (msk) {
s += char(msk & 1);
msk >>= 1;
}
return reverse(s.begin(), s.end());
}
void solve(int msk, int x, int y) {
if (pre[msk][x][y].msk == -1) {
return;
}
if (pre[msk][x][y].msk == 0) {
solve(pre[msk][x][y].x, x, y);
solve(pre[msk][x][y].y, x, y);
} else {
use[x][y] = true;
solve(msk, pre[msk][x][y].x, pre[msk][x][y].y);
}
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> dat[i][j];
}
}
for (int msk = 0; msk < (1 << k); msk++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dp[msk][i][j] = INF;
pre[msk][i][j] = node(-1, -1, -1);
}
}
}
for (int i = 0; i < k; i++) {
int x, y;
cin >> x >> y;
dp[(1 << i)][x][y] = dat[x][y];
use[x][y] = true;
q.push(node(1 << i, x, y));
hav[(1 << i)][x][y] = true;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (!use[i][j]) {
dp[0][i][j] = dat[i][j];
q.push(node(0, i, j));
hav[0][i][j] = true;
}
}
}
while (q.size()) {
node x = q.front();
q.pop();
hav[x.msk][x.x][x.y] = false;
for (int msk = 1; msk < (1 << k); msk++) {
if ((msk & x.msk) == 0) {
if (dp[msk ^ x.msk][x.x][x.y] >
dp[x.msk][x.x][x.y] + dp[msk][x.x][x.y] - dat[x.x][x.y]) {
pre[msk ^ x.msk][x.x][x.y] = node(0, x.msk, msk);
dp[msk ^ x.msk][x.x][x.y] =
dp[x.msk][x.x][x.y] + dp[msk][x.x][x.y] - dat[x.x][x.y];
if (!hav[msk ^ x.msk][x.x][x.y]) {
hav[msk ^ x.msk][x.x][x.y] = true;
q.push(node(msk ^ x.msk, x.x, x.y));
}
}
}
}
for (int i = 0; i < 4; i++) {
int nx = x.x + dx[i];
int ny = x.y + dy[i];
if (nx >= 1 and nx <= n and ny >= 1 and ny <= m) {
if (dp[x.msk][nx][ny] > dp[x.msk][x.x][x.y] + dat[nx][ny]) {
pre[x.msk][nx][ny] = node(1, x.x, x.y);
dp[x.msk][nx][ny] = dp[x.msk][x.x][x.y] + dat[nx][ny];
hav[x.msk][nx][ny] = true;
q.push(node(x.msk, nx, ny));
}
}
}
}
int ans = INF;
node tmp;
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];
tmp = node((1 << k) - 1, i, j);
}
}
}
cout << ans << endl;
solve(tmp.msk, tmp.x, tmp.y);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (use[i][j]) {
cout << "X";
} else {
cout << ".";
}
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
int i, j, k, n, m, a[128][128], z, x, y, t, s, l, b, A, v[128][128],
f[256][128], g[256][128], X[] = {0, 1, 0, -1}, Y[] = {1, 0, -1, 0};
char u[128][128];
char p[] = "0123456789abcdefghijklmnopqrstuvwxyz";
void dfs(int x, int y, int d) {
for (int i = 0; i < 4; ++i) {
t = x + X[i];
s = y + Y[i];
if (t >= 0 && s >= 0 && t < n && s < m)
if (d + a[t][s] < f[t * m + s][z]) {
f[t * m + s][z] = d + a[t][s];
g[t * m + s][z] = 0;
dfs(t, s, d + a[t][s]);
}
}
}
void ff(int x, int y, int z) {
u[x][y] = 'X';
if (g[x * m + y][z] == 0) {
int r = f[x * m + y][z] - a[x][y];
if (r) {
for (int i = 0; i < 4; ++i) {
t = x + X[i];
s = y + Y[i];
if (t >= 0 && s >= 0 && t < n && s < m)
if (f[t * m + s][z] == r) {
ff(t, s, z);
break;
}
}
}
} else {
int w = g[x * m + y][z];
for (int i = 0; i < 4; ++i) {
t = x + X[i];
s = y + Y[i];
if (t >= 0 && s >= 0 && t < n && s < m)
if (f[t * m + s][w] + f[x * m + y][z ^ w] == f[x * m + y][z]) {
ff(t, s, w);
ff(x, y, z ^ w);
break;
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (; i < n; ++i) {
memset(u[i], '.', m);
for (j = 0; j < m; ++j) scanf("%d", a[i] + j);
}
memset(f, 32, sizeof(f));
memset(v, 255, sizeof(v));
for (i = 0; i < k; ++i) {
scanf("%d%d", &x, &y);
--x;
--y;
z = 1 << i;
v[x][y] = i;
dfs(x, y, f[x * m + y][z] = a[x][y]);
}
for (z = 3; z < (1 << k); ++z)
if (__builtin_popcount(z) > 1)
for (x = z - 1; x; x = (x - 1) & z) {
y = x ^ z;
for (i = A = 0; i < n; ++i)
for (j = 0; j < m; ++A, ++j)
for (l = 0; l < 4; ++l) {
t = i + X[l];
s = j + Y[l];
if (t >= 0 && s >= 0 && t < n && s < m) {
b = t * m + s;
if (f[A][x] + f[b][y] < f[A][z]) {
f[A][z] = f[A][x] + f[b][y];
g[A][z] = y;
}
}
}
for (y = 16; y--;)
for (i = A = 0; i < n; ++i)
for (j = 0; j < m; ++A, ++j)
for (l = 0; l < 4; ++l) {
t = i + X[l];
s = j + Y[l];
if (t >= 0 && s >= 0 && t < n && s < m)
if (!~v[t][s]) {
b = t * m + s;
if (f[A][z] + a[t][s] < f[b][z]) {
f[b][z] = f[A][z] + a[t][s];
g[b][z] = 0;
}
}
}
}
for (z = (1 << k) - 1, i = n * m, j = 0; --i;)
if (f[i][z] < f[j][z]) j = i;
printf("%d\n", f[j][z]);
ff(j / m, j % m, z);
for (i = 0; i < n; ++i) puts(u[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int m[101][101], N, M, K;
int dir[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
char b[101][101];
struct Map {
int cost, n, a, b;
Map(int _c, int _n, int _a, int _b) : cost(_c), n(_n), a(_a), b(_b){};
Map(){};
};
Map dp[1 << 7][101][101];
void dfs(int i, int j, int mask) {
b[i][j] = 'X';
if (dp[mask][i][j].n == 1) {
dfs(i, j, dp[mask][i][j].a);
dfs(i, j, dp[mask][i][j].b);
} else if (dp[mask][i][j].n == 2)
dfs(dp[mask][i][j].a, dp[mask][i][j].b, 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", &m[i][j]);
for (int msk = 0; msk < (1 << 7); ++msk)
for (int i = 0; i < N; ++i)
for (int j = 0; j < M; ++j)
dp[msk][i][j].cost = 1 << 20, dp[msk][i][j].n = 0;
for (int i = 0; i < K; ++i) {
int x, y;
scanf("%d%d", &x, &y);
x--, y--;
dp[1 << i][x][y].cost = m[x][y];
}
for (int mask = 0; mask < (1 << 7); ++mask) {
for (int i = 0; i < N; ++i)
for (int j = 0; j < M; ++j)
for (int sub = mask; sub > 0; sub = mask & (sub - 1)) {
int c = dp[sub][i][j].cost + dp[mask ^ sub][i][j].cost - m[i][j];
if (dp[mask][i][j].cost > c)
dp[mask][i][j] = Map(c, 1, sub, mask ^ sub);
}
for (int t = 0; t < N * M; ++t) {
for (int i = 0; i < N; ++i)
for (int j = 0; j < M; ++j)
for (int k = 0; k < 4; ++k) {
int ii = i + dir[k][0], jj = j + dir[k][1];
int c = dp[mask][i][j].cost + m[ii][jj];
if (c < dp[mask][ii][jj].cost) dp[mask][ii][jj] = Map(c, 2, i, j);
}
}
}
int ansc = 1 << 30, ansi, ansj;
for (int i = 0; i < N; ++i)
for (int j = 0; j < M; ++j)
if (dp[(1 << K) - 1][i][j].cost < ansc)
ansc = dp[(1 << K) - 1][i][j].cost, ansi = i, ansj = j;
for (int i = 0; i < N; ++i)
for (int j = 0; j < M; ++j) b[i][j] = '.';
dfs(ansi, ansj, (1 << K) - 1);
printf("%d\n", ansc);
for (int i = 0; i < N; ++i) {
for (int j = 0; j < M; ++j) printf("%c", b[i][j]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T1, class T2>
inline void print(T1 x1, T2 x2) {
printsp(x1), println(x2);
}
template <class T1, class T2, class T3>
inline void print(T1 x1, T2 x2, T3 x3) {
printsp(x1), printsp(x2), println(x3);
}
template <class T1, class T2, class T3, class T4>
inline void print(T1 x1, T2 x2, T3 x3, T4 x4) {
printsp(x1), printsp(x2), printsp(x3), println(x4);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int a[211][211];
int dp[211][211][211];
int dst[211][211];
int id[211][211];
int di[] = {1, -1, 0, 0};
int dj[] = {0, 0, 1, -1};
char res[211][211];
int vst[1011];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
gn(a[i][j]);
vst[a[i][j]]++;
a[i][j] = a[i][j] * 10000 + vst[a[i][j]];
}
int nn = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) id[i][j] = ++nn;
memset(dst, 0x3f3f3f3f, sizeof dst);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
for (int k = 0; k < 4; k++) {
int ii = i + di[k], jj = j + dj[k];
if (ii < 1 or jj < 1 or ii > n or jj > m) continue;
dst[id[i][j]][id[ii][jj]] = a[ii][jj];
dst[id[ii][jj]][id[i][j]] = a[i][j];
}
}
for (int k = 1; k <= nn; k++) {
for (int i = 1; i <= nn; i++) {
for (int j = 1; j <= nn; j++) {
smin(dst[i][j], dst[i][k] + dst[k][j]);
}
}
}
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++) {
dst[id[i][j]][id[ii][jj]] += a[i][j];
}
}
memset(dp, 0x3f3f3f3f, sizeof dp);
for (int i = 0; i < k; i++) {
int first, second;
gn(first, second);
dp[1 << i][first][second] = a[first][second];
}
for (int i = 1; i < 1 << k; i++) {
for (int p = 1; p <= n; p++) {
for (int q = 1; q <= m; q++) {
int b = 0;
while (b = (b - i) & i) {
if (b < i) smin(dp[i][p][q], dp[b][p][q] + dp[i ^ b][p][q] - a[p][q]);
}
}
}
for (int r = 1; r <= n; r++) {
for (int w = 1; w <= m; w++) {
for (int p = 1; p <= n; p++) {
for (int q = 1; q <= m; q++) {
smin(dp[i][p][q], dp[i][r][w] + dst[id[p][q]][id[r][w]] - a[r][w]);
}
}
}
}
}
int ans = 0x3f3f3f3f;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) smin(ans, dp[(1 << k) - 1][i][j]);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) res[i][j] = '.';
cout << ans / 10000 << endl;
int tmp = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (dp[(1 << k) - 1][i][j] == ans)
res[i][j] = 'X', tmp += a[i][j] / 10000;
}
}
if (ans / 10000 != tmp)
while (1)
;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) printf("%c", res[i][j]);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 29;
int dp[210][1 << 7], pre[210][1 << 7];
int n, m, k, nn, mm;
int hash1[210];
int maz[110][110];
char g[110][110];
bool visit[210][1 << 7];
int dx[] = {0, 0, -1, 1};
int dy[] = {-1, 1, 0, 0};
struct Node {
int u, st;
Node() {}
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>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
void da(int *a, int s, int e) {
for (int i = s; i < e; i++) cout << a[i] << " ";
cout << '\n';
}
void db(string s) { cout << s << '\n'; }
void cp(int *a, int *b, int n) {
for (int i = 0; i < n; i++) b[i] = a[i];
}
const long long sn = 250, LOG = 22, MOD = 4294967296, INF = 1 << 30, N = 1 << 8;
int dp[210][N], pre[210][N];
int arr[210][N], val[110][110], n, m, k, dx[4] = {0, 0, 1, -1},
dy[4] = {1, -1, 0, 0};
queue<int> q;
char s[110][110];
void dfs(int pos, int st) {
int x = pos / m, y = pos % m;
s[x][y] = 'X';
if (pre[pos][st] == -1) return;
int pos2 = pre[pos][st] / 1000, pst = pre[pos][st] % 1000;
dfs(pos2, pst);
if (pst != st) dfs(pos2, st - pst);
}
void upd(int pos, int st, int v, int fa) {
if (v > dp[pos][st]) return;
dp[pos][st] = v;
pre[pos][st] = fa;
if (!arr[pos][st]) {
q.push(pos), q.push(st);
arr[pos][st] = 1;
}
}
int main() {
int x, y, x2, y2, pos, st, now;
memset(arr, 0, sizeof(arr));
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
s[i][j] = '.';
cin >> val[i][j];
}
s[i][m] = '\0';
}
int tmp = (1 << k);
for (int i = 0; i < n * m; i++)
for (int j = 0; j < tmp; j++) dp[i][j] = INF;
for (int i = 0; i < k; i++) {
cin >> x >> y;
x--, y--;
upd(x * m + y, (1 << i), val[x][y], -1);
}
while (!q.empty()) {
pos = q.front();
q.pop();
st = q.front();
q.pop();
arr[pos][st] = 0;
x = pos / m, y = pos % m;
for (int i = 0; i < 4; i++) {
x2 = x + dx[i];
y2 = y + dy[i];
if (x2 >= 0 && x2 < n && y2 >= 0 && y2 < m)
upd(x2 * m + y2, st, dp[pos][st] + val[x2][y2], pos * 1000 + st);
}
now = tmp - 1 - st;
for (int i = now; i; i = (i - 1) & now)
upd(pos, st | i, dp[pos][st] + dp[pos][i] - val[x][y], pos * 1000 + st);
}
int ans = INF, res = 0;
for (int i = 0; i < n * m; i++)
if (dp[i][tmp - 1] < ans) res = i, ans = dp[i][tmp - 1];
dfs(res, tmp - 1);
cout << ans << '\n';
for (int i = 0; i < n; i++) cout << s[i] << '\n';
}
|
#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];
struct node {
int dis, x, y;
node(int a, int b, int c) : x(a), y(b), dis(c) {}
bool operator<(const node &a) const { return dis > a.dis; }
};
priority_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);
}
}
while (!qu.empty()) qu.pop();
for (int j = 0; j < n; j++)
for (int k = 0; k < m; k++) qu.push(node(j, k, d[j][k][i]));
while (!qu.empty()) {
node tmp = qu.top();
qu.pop();
int dis = tmp.dis;
int x = tmp.x;
int y = tmp.y;
if (dis > d[x][y][i]) continue;
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);
qu.push(node(nx, ny, d[nx][ny][i]));
}
}
}
}
}
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 INF = (int)1e8;
struct state {
int mask, v;
};
int n, m, k, ans;
int a[200];
int x[7], y[7];
int dist[200][200], pre[200][200];
int visited[200], used[200];
int dp[200][200];
state f[200][200];
void prim(int s) {
memset(visited, 0, sizeof(visited));
visited[s] = 1;
for (int i = 0; i < n * m; i++) {
dist[s][i] = INF;
int x1 = s / m, y1 = s % m, x2 = i / m, y2 = i % m;
if (abs(x1 - x2) + abs(y1 - y2) == 1) {
dist[s][i] = a[i];
pre[s][i] = s;
}
}
dist[s][s] = 0;
for (int i = 1; i < n * m; i++) {
int Min = INF, k;
for (int j = 0; j < n * m; j++)
if (!visited[j] && dist[s][j] < Min) {
Min = dist[s][j];
k = j;
}
visited[k] = 1;
for (int j = 0; j < n * m; j++) {
int x1 = k / m, y1 = k % m, x2 = j / m, y2 = j % m;
if (abs(x1 - x2) + abs(y1 - y2) == 1 && !visited[j] &&
dist[s][j] >= dist[s][k] + a[j]) {
dist[s][j] = dist[s][k] + a[j];
pre[s][j] = k;
}
}
}
}
void print(int mask, int cur) {
if (__builtin_popcount(mask) == 1) {
int t;
for (t = 0; t < k; t++)
if (mask == (1 << t)) break;
while (cur != x[t] * m + y[t]) {
used[cur] = 1;
cur = pre[x[t] * m + y[t]][cur];
}
used[x[t] * m + y[t]] = 1;
return;
}
if (f[mask][cur].mask == mask) {
int v = f[mask][cur].v;
while (cur != v) {
used[cur] = 1;
cur = pre[v][cur];
}
print(mask, v);
return;
}
print(f[mask][cur].mask, cur);
print(mask ^ f[mask][cur].mask, cur);
}
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];
for (int i = 0; i < k; i++) {
cin >> x[i] >> y[i];
x[i]--;
y[i]--;
}
for (int i = 0; i < n * m; i++) prim(i);
for (int i = 0; i < (1 << k); i++)
for (int j = 0; j < n * m; j++) dp[i][j] = INF;
for (int i = 0; i < (1 << k); i++) {
if (__builtin_popcount(i) == 1) {
int t;
for (t = 0; t < k; t++)
if (i == (1 << t)) break;
for (int j = 0; j < n * m; j++)
if (dp[i][j] > a[x[t] * m + y[t]] + dist[x[t] * m + y[t]][j]) {
dp[i][j] = a[x[t] * m + y[t]] + dist[x[t] * m + y[t]][j];
f[i][j].mask = i;
f[i][j].v = j;
}
continue;
}
for (int j = 0; j < i; j++)
if ((i & j) == j)
for (int l = 0; l < n * m; l++)
if (dp[i][l] > dp[j][l] + dp[i ^ j][l] - a[l]) {
dp[i][l] = dp[j][l] + dp[i ^ j][l] - a[l];
f[i][l].mask = j;
f[i][l].v = l;
}
for (int j = 0; j < n * m; j++)
for (int l = 0; l < n * m; l++)
if (dp[i][j] > dp[i][l] + dist[l][j]) {
dp[i][j] = dp[i][l] + dist[l][j];
f[i][j].mask = i;
f[i][j].v = l;
}
}
ans = INF;
for (int i = 0; i < n * m; i++) ans = min(ans, dp[(1 << k) - 1][i]);
for (int i = 0; i < n * m; i++)
if (ans == dp[(1 << k) - 1][i]) {
print((1 << k) - 1, i);
break;
}
cout << ans << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (used[i * m + j])
cout << "X";
else
cout << ".";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
const int N = 205;
const int A = 7;
int sx[4] = {0, 0, 1, -1};
int sy[4] = {1, -1, 0, 0};
int id[A];
int d[N][N];
int r[N][N];
int dp[1 << A][N];
int path[1 << A][N];
int submask1[1 << A][N];
int submask2[1 << A][N];
int val[N][N];
int px[N];
int py[N];
char str[N][N];
void DrawMap(int d1, int d2) {
if (r[d1][d2] == d1 || r[d1][d2] == d2) {
str[px[d1]][py[d1]] = 'X';
str[px[d2]][py[d2]] = 'X';
return;
}
str[px[r[d1][d2]]][py[r[d1][d2]]] = 'X';
DrawMap(d1, r[d1][d2]);
DrawMap(r[d1][d2], d2);
}
void PrintRoute(int mask, int mk) {
if (mask == 1 || mask == 2 || mask == 4 || mask == 8 || mask == 16 ||
mask == 32 || mask == 64 || mask == 128) {
DrawMap(path[mask][mk], mk);
return;
}
if (path[mask][mk] != -1) {
DrawMap(path[mask][mk], mk);
PrintRoute(submask1[mask][mk], path[mask][mk]);
return;
}
PrintRoute(submask1[mask][mk], mk);
PrintRoute(submask2[mask][mk], mk);
}
int Steiner(int n, int a) {
int top = 1 << a;
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (d[i][j] > d[i][k] + d[k][j] - val[px[k]][py[k]]) {
d[i][j] = d[i][k] + d[k][j] - val[px[k]][py[k]];
r[i][j] = k;
}
}
}
}
for (int i = 0; i < top; i++) {
for (int j = 0; j < n; j++) {
dp[i][j] = inf;
path[i][j] = -1;
}
}
for (int i = 0; i < a; i++) {
for (int j = 0; j < n; j++) {
dp[1 << i][j] = d[id[i]][j];
path[1 << i][j] = id[i];
}
}
for (int i = 1; i < top; i++) {
if ((i & (i - 1)) == 0) continue;
for (int k = 0; k < n; k++) {
for (int j = 1; j < i; j++) {
if ((i | j) == i &&
dp[i][k] > dp[j][k] + dp[i - j][k] - val[px[k]][py[k]]) {
dp[i][k] = dp[j][k] + dp[i - j][k] - val[px[k]][py[k]];
path[i][k] = -1;
submask1[i][k] = j;
submask2[i][k] = i - j;
}
}
}
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
if (dp[i][j] > dp[i][k] + d[k][j] - val[px[k]][py[k]]) {
dp[i][j] = dp[i][k] + d[k][j] - val[px[k]][py[k]];
path[i][j] = k;
submask1[i][j] = i;
}
}
}
}
int ans = inf;
int mk = -1;
for (int i = 0; i < n; i++) {
if (ans > dp[top - 1][i]) {
ans = dp[top - 1][i];
mk = i;
}
}
PrintRoute(top - 1, mk);
return ans;
}
int main() {
int n, m, k, x, y;
while (scanf("%d %d %d", &n, &m, &k) != EOF) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
scanf("%d", &val[i][j]);
str[i][j] = '.';
px[i * m + j] = i;
py[i * m + j] = j;
}
for (int i = 0; i < k; i++) {
scanf("%d %d", &x, &y);
id[i] = (x - 1) * m + y - 1;
}
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++) d[i][j] = inf;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
d[i * m + j][i * m + j] = val[i][j];
r[i * m + j][i * m + j] = i * m + j;
for (int t = 0; t < 4; t++) {
int fx = i + sx[t];
int fy = j + sy[t];
if (fx >= 0 && fx < n && fy >= 0 && fy < m) {
d[fx * m + fy][i * m + j] = d[i * m + j][fx * m + fy] =
val[i][j] + val[fx][fy];
r[fx * m + fy][i * m + j] = r[i * m + j][fx * m + fy] = i * m + j;
}
}
}
}
printf("%d\n", Steiner(n * m, k));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
printf("%c", str[i][j]);
}
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool checkmax(T &a, T b) {
return a < b ? a = b, true : false;
}
template <class T>
bool checkmin(T &a, T b) {
return a > b ? a = b, true : false;
}
template <class T>
void string_reader(string s, vector<T> &vec) {
istringstream sin(s);
copy(istream_iterator<T>(sin), istream_iterator<T>(), back_inserter(vec));
}
const int N = 200;
const int K = 7;
const int INF = N * N * 10000;
const int dx[] = {0, 0, 1, -1};
const int dy[] = {1, -1, 0, 0};
int matrix[N][N];
int dp[N][N][1 << K], inq[N][N][1 << K];
tuple<int, int, int> pre[N][N][1 << K];
tuple<int, int> nodes[K];
int n, m, k;
bool is_legal(int x, int y) { return 0 <= x && x < n && 0 <= y && y < m; }
char fig[N][N];
void dfs(int x, int y, int s) {
fig[x][y] = 'X';
int tmpx = get<0>(pre[x][y][s]), tmpy = get<1>(pre[x][y][s]),
tmps = get<2>(pre[x][y][s]);
if (tmpx == -1)
return;
else if (x == tmpx && y == tmpy) {
dfs(x, y, s ^ tmps);
dfs(x, y, tmps);
} else
dfs(tmpx, tmpy, tmps);
}
void DP() {
int als = 1 << k;
for (int i = 0; i < int(n); ++i)
for (int j = 0; j < int(m); ++j) {
fill(dp[i][j], dp[i][j] + als, INF);
memset(pre[i][j], -1, sizeof(pre[i][j]));
for (int kk = 0; kk < int(als); ++kk) {
get<0>(pre[i][j][kk]) = -1;
get<1>(pre[i][j][kk]) = -1;
get<2>(pre[i][j][kk]) = -1;
}
}
memset(inq, false, sizeof(inq));
queue<tuple<int, int, int> > q;
for (int i = 0; i < int(k); ++i) {
int x = get<0>(nodes[i]), y = get<1>(nodes[i]);
dp[x][y][1 << i] = matrix[x][y];
inq[x][y][1 << i] = true;
q.push(tuple<int, int, int>(x, y, 1 << i));
}
while (q.empty() == false) {
auto now = q.front();
q.pop();
int x = get<0>(now), y = get<1>(now), s = get<2>(now);
for (int kk = 0; kk < int(4); ++kk) {
int tmpx = x + dx[kk];
int tmpy = y + dy[kk];
if (is_legal(tmpx, tmpy) == false) continue;
if (checkmin(dp[tmpx][tmpy][s], dp[x][y][s] + matrix[tmpx][tmpy])) {
get<0>(pre[tmpx][tmpy][s]) = x;
get<1>(pre[tmpx][tmpy][s]) = y;
get<2>(pre[tmpx][tmpy][s]) = s;
if (!inq[tmpx][tmpy][s]) {
q.push(tuple<int, int, int>(tmpx, tmpy, s));
inq[tmpx][tmpy][s] = 1;
}
}
}
for (int kk = 0; kk < int(4); ++kk) {
int nxts = (als - 1) ^ s;
for (int i = nxts; i != 0; i = (i - 1) & nxts) {
if (checkmin(dp[x][y][i | s],
dp[x][y][i] + dp[x][y][s] - matrix[x][y])) {
get<0>(pre[x][y][s | i]) = x;
get<1>(pre[x][y][s | i]) = y;
get<2>(pre[x][y][s | i]) = s;
if (!inq[x][y][i | s]) {
q.push(tuple<int, int, int>(x, y, i | s));
inq[x][y][i | s] = 1;
}
}
}
}
inq[x][y][s] = false;
}
int ans = INF;
pair<int, int> p;
for (int i = 0; i < int(n); ++i)
for (int j = 0; j < int(m); ++j)
if (checkmin(ans, dp[i][j][als - 1])) p = make_pair(i, j);
cout << ans << endl;
dfs(p.first, p.second, als - 1);
for (int i = 0; i < int(n); ++i)
for (int j = 0; j < int(m); ++j) {
cout << fig[i][j];
if (j == m - 1) cout << endl;
}
}
int main() {
while (cin >> n >> m >> k) {
for (int i = 0; i < int(n); ++i)
for (int j = 0; j < int(m); ++j) cin >> matrix[i][j];
memset(fig, '.', sizeof(fig));
for (int i = 0; i < int(k); ++i) {
cin >> get<0>(nodes[i]) >> get<1>(nodes[i]);
get<0>(nodes[i])--;
get<1>(nodes[i])--;
}
DP();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 100100;
struct State {
int y, x, cost, bit;
vector<pair<int, int> > check;
};
bool operator<(const State& a, const State& b) { return a.cost > b.cost; }
bool visit[1 << 7 + 1][128][128];
int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
int main() {
int n, m, k;
while (cin >> n >> m >> k) {
int root[128][128];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> root[i][j];
for (int i = 0; i < 1 << k; i++)
for (int j = 0; j < n; j++)
for (int kk = 0; kk < m; kk++) visit[i][j][kk] = false;
priority_queue<State> Q;
int f[128][128] = {0};
bool ans[128][128] = {0};
for (int i = 0; i < k; i++) {
vector<pair<int, int> > ss;
int x, y;
cin >> y >> x;
x--;
y--;
f[y][x] = i + 1;
ans[y][x] = true;
Q.push((State){y, x, root[y][x], 0, ss});
}
while (!Q.empty()) {
State b = Q.top();
Q.pop();
if (f[b.y][b.x] != 0)
if (!(b.bit & (1 << (f[b.y][b.x] - 1)))) {
b.bit += (1 << (f[b.y][b.x] - 1));
for (__typeof((b.check).begin()) it = (b.check).begin();
it != (b.check).end(); ++it)
visit[b.bit][(*it).first][(*it).second] = true;
for (__typeof((b.check).begin()) it = (b.check).begin();
it != (b.check).end(); ++it) {
for (int i = 0; i < 4; i++) {
int y = dy[i] + (*it).first, x = dx[i] + (*it).second, c;
if (x < 0 || y < 0 || y == n || x == m || visit[b.bit][y][x])
continue;
c = b.cost + root[y][x];
Q.push((State){y, x, c, b.bit, b.check});
}
}
}
if (visit[b.bit][b.y][b.x]) continue;
visit[b.bit][b.y][b.x] = true;
b.check.push_back(make_pair(b.y, b.x));
if (b.bit == ((1 << k) - 1)) {
cout << b.cost << endl;
for (int i = 0; i < b.check.size(); i++)
ans[b.check[i].first][b.check[i].second] = true;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (ans[i][j])
cout << "X";
else
cout << ".";
}
cout << endl;
}
break;
}
for (int i = 0; i < 4; i++) {
int x = dx[i] + b.x, y = dy[i] + b.y, c;
if (x < 0 || y < 0 || y == n || x == m || visit[b.bit][y][x]) continue;
c = b.cost + root[y][x];
Q.push((State){y, x, c, b.bit, b.check});
}
}
}
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 - M[i][j];
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();
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;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
int n, m, kk, dp[139][109][109], imp[109][109];
int arr[109][109], dis[309][309];
int dx[] = {+1, -1, 0, 0};
int dy[] = {0, 0, +1, -1};
int rec(int msk, int x, int y) {
int& ret = dp[msk][x][y];
if (~ret) return ret;
ret = 1000000007;
return ret;
}
int ok(int x, int y) { return (x >= 1 and y >= 1 and x <= n and y <= m); }
void go(int x, int y) {
queue<pair<int, int> > q;
dis[(x - 1) * m + y][(x + 1) * m + y] = arr[x][y];
q.push(make_pair(x, y));
while (!q.empty()) {
int nx = q.front().first;
int ny = q.front().second;
q.pop();
for (int i = 0; i < 4; i++) {
int tox = dx[i] + nx;
int toy = dy[i] + ny;
if (!ok(tox, toy)) continue;
if (umin(dis[(x - 1) * m + y][(tox + 1) * m + toy],
dis[(x - 1) * m + y][(nx + 1) * m + ny] + arr[tox][toy]))
q.push(make_pair(tox, toy));
}
}
}
void dead(int nx, int ny, int x1, int y1) {
imp[x1][y1] = 1;
while (nx != x1 or ny != y1) {
imp[nx][ny] = 1;
for (int i = 0; i < 4; i++) {
int tox = nx + dx[i];
int toy = ny + dy[i];
if (!ok(tox, toy)) continue;
if (dis[(nx - 1) * m + ny][(x1 + 1) * m + y1] ==
dis[(tox - 1) * m + toy][(x1 + 1) * m + y1] + arr[nx][ny]) {
nx = tox;
ny = toy;
break;
}
}
}
}
void doldur(int bits, int x, int y) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int k = bits; k; k = ((k - 1) & bits))
if (dp[bits][x][y] ==
(dp[k][i][j] + dp[k ^ bits][i][j] - arr[i][j] +
dis[(x - 1) * m + y][(i + 1) * m + j] - arr[i][j]) and
make_pair(bits, make_pair(x, y)) != make_pair(k, make_pair(i, j))) {
doldur(k, i, j);
doldur(k ^ bits, i, j);
dead(x, y, i, j);
return;
}
}
int main() {
memset(dp, 31, sizeof(dp));
memset(dis, 31, sizeof(dis));
scanf("%d%d%d", &n, &m, &kk);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &arr[i][j]);
for (int i = 1; i <= kk; i++) {
int x, y;
scanf("%d%d", &x, &y);
imp[x][y] = 1;
dp[1 << (i - 1)][x][y] = arr[x][y];
}
int x1, y1, mn = 1000000007, mask = (1 << kk) - 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
dp[0][i][j] = arr[i][j];
go(i, j);
}
for (int msk = 1; msk <= mask; msk++)
for (int x = 1; x <= n; x++)
for (int y = 1; y <= m; y++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int k = msk; k; k = ((k - 1) & msk))
umin(dp[msk][x][y], dp[k][i][j] + dp[msk ^ k][i][j] - arr[i][j] +
dis[(x - 1) * m + y][(i + 1) * m + j] -
arr[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (umin(mn, dp[mask][i][j])) x1 = i, y1 = j;
doldur(mask, x1, y1);
printf("%d\n", mn);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (imp[i][j])
printf("X");
else
printf(".");
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1061109567;
const int MaxN = 205;
const int MaxM = 300;
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
int n, m, K;
int dp[MaxN][MaxM], pre[MaxN][MaxM];
int mat[MaxN], vis[MaxN], st[MaxN];
char in[MaxN][MaxM];
queue<int> q;
void spfa() {
while (!q.empty()) {
int top = q.front();
q.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;
q.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, 0x3f, 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] != INF) in[i][s] = 1, q.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 a[205][205];
int b[205];
int edge[205][205];
long long dis[205][205];
long long dp[131][205];
vector<pair<int, int> > la[131][205];
int imp[13];
int dila[205][205];
bool had[205];
void solve(int x1, int x2) {
queue<pair<int, int> > q;
q.push(make_pair(x1, x2));
had[x1] = 1;
had[x2] = 1;
while (!q.empty()) {
int a1 = q.front().first, b1 = q.front().second;
q.pop();
had[dila[a1][b1]] = 1;
if (~dila[a1][b1]) {
q.push(make_pair(a1, dila[a1][b1]));
q.push(make_pair(dila[a1][b1], b1));
}
}
}
int main() {
int n, m, K;
cin >> n >> m >> K;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
b[i * m + j] = a[i][j];
if (i - 1 >= 0)
edge[(i - 1) * m + j][i * m + j] = edge[i * m + j][(i - 1) * m + j] = 1;
if (i + 1 < n)
edge[(i + 1) * m + j][i * m + j] = edge[i * m + j][(i + 1) * m + j] = 1;
if (j - 1 >= 0)
edge[i * m + j - 1][i * m + j] = edge[i * m + j][i * m + j - 1] = 1;
if (j + 1 < m)
edge[i * m + j + 1][i * m + j] = edge[i * m + j][i * m + j + 1] = 1;
}
}
int al = n * m;
memset(dila, -1, sizeof dila);
for (int i = 0; i < al; i++) {
for (int j = 0; j < al; j++) {
if (edge[i][j])
dis[i][j] = b[i] + b[j];
else
dis[i][j] = 1e9;
}
dis[i][i] = b[i];
}
for (int k = 0; k < al; k++) {
for (int i = 0; i < al; i++) {
for (int j = 0; j < al; j++) {
if (dis[i][j] > dis[i][k] + dis[k][j] - b[k]) {
dila[i][j] = k;
dis[i][j] = dis[i][k] + dis[k][j] - b[k];
}
}
}
}
for (int i = 0; i < K; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
imp[i] = x * m + y;
}
for (int j = 0; j < al; j++) {
for (int k = 0; k < 1 << K; k++) {
dp[k][j] = 1e9;
}
}
for (int i = 0; i < K; i++) {
dp[1 << i][imp[i]] = b[imp[i]];
had[imp[i]] = 1;
}
dp[0][0] = 0;
for (int i = 1; i < 1 << K; i++) {
for (int j = 0; j < al; j++) {
for (int k = (i - 1) & i; k; k = (k - 1) & i) {
if (dp[i ^ k][j] + dp[k][j] - b[j] < dp[i][j]) {
dp[i][j] = dp[i ^ k][j] + dp[k][j] - b[j];
la[i][j].clear();
la[i][j].push_back(make_pair(i ^ k, j));
la[i][j].push_back(make_pair(k, j));
}
}
}
for (int j = 0; j < al; j++)
for (int k = 0; k < al; k++) {
if (dp[i][j] > dp[i][k] + dis[k][j] - b[k]) {
dp[i][j] = dp[i][k] + dis[k][j] - b[k];
la[i][j].clear();
la[i][j].push_back(make_pair(i, k));
}
}
}
long long mi = 1e9, id;
for (int i = 0; i < al; i++) {
if (mi > dp[(1 << K) - 1][i]) {
mi = dp[(1 << K) - 1][i];
id = i;
}
}
queue<pair<int, int> > q;
q.push(make_pair((1 << K) - 1, id));
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop();
had[y] = 1;
for (int i = 0; i < la[x][y].size(); i++) {
int x1 = la[x][y][i].first, y1 = la[x][y][i].second;
solve(y1, y);
q.push(make_pair(x1, y1));
}
}
cout << mi << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (had[i * m + j])
cout << 'X';
else
cout << '.';
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxSum = 205, maxSet = 1 << 8, flag = 1 << 30, maxinf = 1 << 29;
int n, m, k, sum, dis[maxSum][maxSum], solDis[maxSum][maxSum],
dp[maxSum][maxSet], sol[maxSum][maxSet], tar[10], w[maxSum];
int encode(int x, int y) { return x * m + y; }
void decode(int grid, int &x, int &y) {
x = grid / m;
y = grid % m;
}
bool connect(int g1, int g2) {
int x1, y1, x2, y2;
decode(g1, x1, y1);
decode(g2, x2, y2);
return abs(x1 - x2) + abs(y1 - y2) <= 1;
}
void floyd() {
for (int i = 0; i < sum; i++)
for (int j = 0; j < sum; j++) {
if (i == j) {
dis[i][j] = 0;
solDis[i][j] = -1;
} else if (connect(i, j)) {
dis[i][j] = w[j];
solDis[i][j] = -1;
} else
dis[i][j] = maxinf;
}
for (int k = 0; k < sum; k++) {
for (int i = 0; i < sum; i++)
if (dis[i][k] != maxinf) {
for (int j = 0; j < sum; j++)
if (dis[k][j] != maxinf && i != j) {
if (dis[i][j] > dis[i][k] + dis[k][j]) {
dis[i][j] = dis[i][k] + dis[k][j];
solDis[i][j] = k;
}
}
}
}
for (int i = 0; i < sum; i++)
for (int j = 0; j < sum; j++) dis[i][j] += w[i];
}
void paintTwo(int s, int e) {
int x1, y1, x2, y2, x3 = -1, y3 = -1;
decode(s, x1, y1);
decode(e, x2, y2);
if (solDis[s][e] != -1) decode(solDis[s][e], x3, y3);
if (solDis[s][e] == -1) {
w[s] = w[e] = -1;
return;
} else {
paintTwo(s, solDis[s][e]);
paintTwo(solDis[s][e], e);
}
}
void paintRoad(int grid, int set) {
w[grid] = -1;
if (set == 0) return;
if (!(set & (set - 1))) {
int i = -1;
for (; set > 0; set >>= 1, i++)
;
paintTwo(grid, tar[i]);
} else if (flag & sol[grid][set]) {
paintTwo(grid, sol[grid][set]);
paintRoad(sol[grid][set] ^ flag, set);
} else {
paintRoad(grid, sol[grid][set]);
paintRoad(grid, sol[grid][set] ^ set);
}
}
int main() {
cin >> n >> m >> k;
sum = n * m;
for (int i = 0; i < sum; i++) cin >> w[i];
for (int i = 0, tx, ty; i < k; i++) {
cin >> tx >> ty;
tx--;
ty--;
tar[i] = encode(tx, ty);
}
floyd();
for (int i = 0; i < sum; i++)
for (int t = 0; t < k; t++) {
dp[i][1 << t] = dis[i][tar[t]];
}
for (int s = 0; s < (1 << k); s++)
if (s & (s - 1)) {
for (int i = 0; i < sum; i++) {
dp[i][s] = maxinf;
for (int ns = s & (s - 1); ns; ns = (ns - 1) & s) {
int tmp = dp[i][ns] + dp[i][s ^ ns] - w[i];
if (dp[i][s] > tmp) {
dp[i][s] = tmp;
sol[i][s] = ns;
}
}
}
for (int i = 0; i < sum; i++)
for (int j = 0; j < sum; j++) {
int tmp = dp[j][s] + dis[i][j] - w[j];
if (dp[i][s] > tmp) {
dp[i][s] = tmp;
sol[i][s] = flag | j;
}
}
}
cout << dp[tar[0]][(1 << k) - 1] << endl;
paintRoad(tar[0], (1 << k) - 1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int g = encode(i, j);
if (w[g] == -1)
cout << "X";
else
cout << ".";
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, K;
int co[105][105];
int dis[205][1 << 7];
int key[105][105];
int pi[205][1 << 7], ps[205][1 << 7];
bool inq[205][1 << 7];
queue<int> que;
inline int ind(int x, int y) { return x * m + y; }
inline void insertq(int i, int sta, int val, int PI, int PS) {
if (dis[i][sta] == -1 || dis[i][sta] > val) {
dis[i][sta] = val;
pi[i][sta] = PI;
ps[i][sta] = PS;
if (!inq[i][sta]) {
que.push(i);
que.push(sta);
inq[i][sta] = true;
}
}
}
int dir[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
int M;
void bfs() {
memset(inq, false, sizeof(inq));
while (!que.empty()) que.pop();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (key[i][j] == -1) continue;
insertq(ind(i, j), 1 << key[i][j], co[i][j], -1, 0);
}
}
M = (1 << K) - 1;
while (!que.empty()) {
int u = que.front();
que.pop();
int s = que.front();
que.pop();
inq[u][s] = false;
int bs = M ^ s;
int x = u / m, y = u % m;
for (int i = bs; i; i = bs & (i - 1)) {
if (dis[u][i] == -1) continue;
insertq(u, i | s, dis[u][s] + dis[u][i] - co[x][y], u, i);
}
for (int i = 0; i < 4; i++) {
int tx = x + dir[i][0], ty = y + dir[i][1];
if (tx < 0 || tx >= n || ty < 0 || ty >= m) continue;
insertq(ind(tx, ty), s, dis[u][s] + co[tx][ty], u, s);
}
}
}
bool cov[205][205];
bool vis[205][1 << 7];
void DFS(int u, int s) {
if (u == -1 || s == 0) return;
cov[u / m][u % m] = true;
vis[u][s] = true;
int v = pi[u][s], ss = ps[u][s];
if (!vis[v][ss]) DFS(v, ss);
if (!vis[u][ss ^ s]) DFS(u, ss ^ s);
}
void gao() {
int ans = 0x7fffffff;
int u = -1, s = -1;
for (int i = 0; i < n * m; i++) {
if (dis[i][M] == -1) continue;
if (dis[i][M] < ans) {
ans = dis[i][M];
u = i;
s = M;
}
}
printf("%d\n", ans);
memset(cov, false, sizeof(cov));
memset(vis, false, sizeof(vis));
DFS(u, s);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
putchar(cov[i][j] ? 'X' : '.');
}
puts("");
}
}
int main() {
while (~scanf("%d%d%d", &n, &m, &K)) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &co[i][j]);
memset(key, -1, sizeof(key));
int ind = 0;
for (int i = 0; i < K; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--, y--;
key[x][y] = ind++;
}
memset(dis, -1, sizeof(dis));
memset(pi, -1, sizeof(pi));
memset(ps, -1, sizeof(ps));
bfs();
gao();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MXN = 202, MXK = 7;
int n, m, k, A[MXN], dp[MXN][1 << MXK];
bitset<MXN> db[MXN][1 << MXK];
priority_queue<pair<int, int> > Pq;
inline void Relax(int i, int v, int u) {
if (dp[u][i] > dp[v][i] + A[u]) {
dp[u][i] = dp[v][i] + A[u];
db[u][i] = db[v][i];
db[u][i][u] = 1;
Pq.push({-dp[u][i], u});
}
}
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)*m + j)]);
memset(dp, 63, sizeof(dp));
for (int i = 0; i < k; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
dp[((a)*m + b)][1 << i] = A[((a)*m + b)];
db[((a)*m + b)][1 << i][((a)*m + b)] = 1;
}
for (int i = 0; i < (1 << k); i++) {
for (int j = 0; j < n * m; j++) {
for (int sub = i; sub; sub = (sub - 1) & i)
if (dp[j][sub] + dp[j][i ^ sub] - A[j] < dp[j][i]) {
dp[j][i] = dp[j][sub] + dp[j][i ^ sub] - A[j];
db[j][i] = db[j][sub] | db[j][i ^ sub];
}
Pq.push({-dp[j][i], j});
}
while (Pq.size()) {
int v = Pq.top().second;
int d = -Pq.top().first;
Pq.pop();
if (d > dp[v][i]) continue;
int a = v / m, b = v % m;
if (a > 0) Relax(i, v, v - m);
if (a < n - 1) Relax(i, v, v + m);
if (b > 0) Relax(i, v, v - 1);
if (b < m - 1) Relax(i, v, v + 1);
}
}
int id = 0;
for (int i = 0; i < n * m; i++)
if (dp[i][(1 << k) - 1] < dp[id][(1 << k) - 1]) id = i;
printf("%d\n", dp[id][(1 << k) - 1]);
for (int i = 0; i < n * m; i++) {
if (db[id][(1 << k) - 1][i])
printf("X");
else
printf(".");
if (i % m == m - 1) printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105, maxk = 128, INF = 1e9 + 7;
inline int read() {
int w = 0, f = 1;
char ch = getchar();
while (ch < '0' or ch > '9') {
if (ch == '-') f = -f;
ch = getchar();
}
while (ch >= '0' and ch <= '9') w = w * 10 + ch - '0', ch = getchar();
return w * f;
}
int dis[maxn][maxn][maxk], N, M, K, a[maxn][maxn], Map[maxn][maxn], X[10],
Y[10], dx[4] = {0, 0, 1, -1}, dy[4] = {1, -1, 0, 0};
queue<pair<pair<int, int>, int> > q;
bool vis[maxn][maxn][maxk];
int pre[maxn][maxn][maxk][3];
char way[maxn][maxn];
void dfs(int x, int y, int mask) {
way[x][y] = 'X';
if (pre[x][y][mask][0] == 0) return;
if (pre[x][y][mask][0] == 2) {
dfs(pre[x][y][mask][1], pre[x][y][mask][2], mask);
} else if (pre[x][y][mask][0] == 1) {
dfs(x, y, pre[x][y][mask][1]);
dfs(x, y, pre[x][y][mask][2]);
}
}
int main() {
N = read(), M = read(), K = read();
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++)
for (int mask = 0; mask < (1 << K); mask++) dis[i][j][mask] = INF;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++) a[i][j] = read(), way[i][j] = '.';
for (int i = 0; i < K; i++) {
X[i] = read(), Y[i] = read();
dis[X[i]][Y[i]][1 << i] = a[X[i]][Y[i]], vis[X[i]][Y[i]][1 << i] = 1,
Map[X[i]][Y[i]] = 1 << i;
q.push(make_pair(make_pair(X[i], Y[i]), 1 << i));
}
while (!q.empty()) {
pair<int, int> co = q.front().first;
int mask = q.front().second;
q.pop();
vis[co.first][co.second][mask] = false;
for (int i = 0; i < (1 << K); i++) {
if ((i | mask) == mask) continue;
if (dis[co.first][co.second][i | mask] > dis[co.first][co.second][mask] +
dis[co.first][co.second][i] -
a[co.first][co.second]) {
dis[co.first][co.second][i | mask] = dis[co.first][co.second][mask] +
dis[co.first][co.second][i] -
a[co.first][co.second];
pre[co.first][co.second][i | mask][0] = 1;
pre[co.first][co.second][i | mask][1] = mask;
pre[co.first][co.second][i | mask][2] = i;
if (!vis[co.first][co.second][i | mask]) {
vis[co.first][co.second][i | mask] = true;
q.push(make_pair(co, i | mask));
}
}
}
for (int i = 0; i < 4; i++) {
int tox = co.first + dx[i], toy = co.second + dy[i];
if (tox < 1 or toy < 1 or tox > N or toy > M) continue;
if (dis[tox][toy][mask] > dis[co.first][co.second][mask] + a[tox][toy]) {
dis[tox][toy][mask] = dis[co.first][co.second][mask] + a[tox][toy];
pre[tox][toy][mask][0] = 2;
pre[tox][toy][mask][1] = co.first;
pre[tox][toy][mask][2] = co.second;
if (!vis[tox][toy][mask]) {
vis[tox][toy][mask] = true;
q.push(make_pair(make_pair(tox, toy), mask));
}
}
}
}
int ans = INF;
pair<pair<int, int>, int> pos;
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];
pos = make_pair(make_pair(i, j), (1 << K) - 1);
}
}
}
int nowx = pos.first.first, nowy = pos.first.second, nowmask = pos.second;
cout << ans << endl;
int ans2 = 0;
dfs(nowx, nowy, nowmask);
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
cout << way[i][j];
}
cout << 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[111][111];
int n, m, k;
vector<pair<int, int> > pos;
int ddist[111][111], way[10][10], dist[211][10];
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};
queue<pair<int, int> > que;
void bfs(int x, int y, int o) {
int i, j, u, v;
while (!que.empty()) que.pop();
que.push(make_pair(x, y));
for (i = 0; i <= n + 1; i++)
for (j = 0; j <= m + 1; j++) ddist[i][j] = -1;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) ddist[i][j] = MOD;
ddist[x][y] = val[x][y];
dp[(x - 1) * m + y][1 << o] = val[x][y];
while (!que.empty()) {
u = que.front().first, v = que.front().second;
que.pop();
for (i = 0; i < 4; i++) {
x = u + dx[i];
y = v + dy[i];
if (ddist[x][y] == -1) continue;
if (ddist[x][y] > ddist[u][v] + val[x][y]) {
ddist[x][y] = ddist[u][v] + val[x][y];
dp[(x - 1) * m + y][1 << o] = ddist[x][y];
pre[(x - 1) * m + y][1 << o] = make_pair((u - 1) * m + v, 1 << o);
que.push(make_pair(x, y));
}
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
dist[(i - 1) * m + j][o] = ddist[i][j];
}
}
}
set<pair<int, 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++) {
scanf("%d", &val[i][j]);
}
}
pos.clear();
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;
}
}
}
for (i = 0; i < k; i++) {
scanf("%d%d", &u, &v);
pos.push_back(make_pair(u, v));
bfs(u, v, i);
}
S[0].clear();
S[1].clear();
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
S[0].insert(make_pair(i, j));
}
}
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()) {
u = S[uu].begin()->first;
v = S[uu].begin()->second;
S[uu].erase(S[uu].begin());
p = (u - 1) * m + v;
for (i = 0; i < 4; i++) {
x = u + dx[i];
y = v + dy[i];
if (x < 1 || x > n || y < 1 || y > m) continue;
q = (x - 1) * m + y;
for (l = 0; l < (1 << k); l++) {
if (dp[q][l] > dp[p][l] + val[x][y]) {
dp[q][l] = dp[p][l] + val[x][y];
pre[q][l] = make_pair(p, l);
S[vv].insert(make_pair(x, y));
}
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(make_pair(x, y));
}
}
}
}
}
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 Max = 210, Mask = (1 << 7) + 10;
int dp[Mask][Max], ds[Max][Max], bef[Max][Max];
pair<int, int> par[Mask][Max];
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int a[Max][Max], n, m, k;
pair<int, int> p[10];
bool in[Max];
void cover(int a, int b, int c, int d) {
int x = a * m + b, y = c * m + d;
while (y != x) {
in[y] = 1;
y = bef[x][y];
}
in[x] = 1;
}
int CNT = 0;
void f(int i, int j, int msk) {
if (msk == 0) {
cover(i, j, i, j);
return;
}
if (__builtin_popcount(msk) == 1) {
int id = __builtin_ctz(msk);
cover(i, j, p[id].first, p[id].second);
return;
}
int x = par[msk][i * m + j].second / m, y = par[msk][i * m + j].second % m;
cover(i, j, x, y);
f(x, y, par[msk][i * m + j].first);
f(i, j, msk ^ par[msk][i * m + j].first);
}
int main() {
ios_base::sync_with_stdio(false);
cin.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 < k; i++) {
cin >> p[i].first >> p[i].second;
p[i].first--, p[i].second--;
}
for (int i = 0; i < Max; i++)
for (int j = 0; j < Max; j++) ds[i][j] = (i == j ? 0 : 1e9), bef[i][j] = i;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int go = 0; go < 4 * n * m; go++) {
for (int ii = 0; ii < n; ii++) {
for (int jj = 0; jj < m; jj++) {
for (int k = 0; k < 4; k++) {
int x = dx[k] + ii, y = dy[k] + jj;
if (x >= 0 && y >= 0 && x < n && y < m) {
if (ds[i * m + j][x * m + y] + a[x][y] <
ds[i * m + j][ii * m + jj])
ds[i * m + j][ii * m + jj] =
ds[i * m + j][x * m + y] + a[x][y],
bef[i * m + j][ii * m + jj] =
x * m + y;
}
}
}
}
}
}
}
int ans = 1e9, posx = -1, posy = -1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
dp[0][i * m + j] = a[i][j];
}
}
for (int msk = 1; msk < (1 << k); msk++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int &num = dp[msk][i * m + j] = 1e9;
pair<int, int> &pr = par[msk][i * m + j] = {-1, -1};
for (int msk2 = 1; msk2 < msk; msk2++) {
if ((msk2 | msk) != msk) continue;
for (int ii = 0; ii < n; ii++) {
for (int jj = 0; jj < m; jj++) {
int x = dp[msk2][ii * m + jj] + ds[ii * m + jj][i * m + j] -
a[ii][jj] + dp[msk ^ msk2][i * m + j];
if ((ii != i || jj != j) && x < num)
pr = {msk2, (ii * m + jj)}, num = x;
}
}
}
int id = -1;
for (int w = 0; w < k; w++) {
if ((((msk) >> (w)) & 1) && p[w].first == i && p[w].second == j)
id = w;
}
if (id != -1) {
dp[msk][i * m + j] = dp[msk ^ (1 << id)][i * m + j],
par[msk][i * m + j] = {msk ^ (1 << id), i * m + j};
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int ii = 0; ii < n; ii++) {
for (int jj = 0; jj < m; jj++) {
int x = dp[msk][ii * m + jj] + ds[i * m + j][ii * m + jj];
if (dp[msk][i * m + j] > x)
dp[msk][i * m + j] = x, par[msk][i * m + j] = {msk, ii * m + jj};
}
}
if (msk == (1 << k) - 1 && dp[msk][i * m + j] < ans)
ans = dp[msk][i * m + j], posx = i, posy = j;
}
}
}
f(posx, posy, (1 << k) - 1);
cout << ans << "\n";
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (in[i * m + j])
cout << 'X';
else
cout << '.';
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int n, m, k;
cin >> n >> m >> k;
int a[n][m];
int id[n][m];
int vx[n * m];
int vy[n * m];
int index = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
cin >> a[i][j];
id[i][j] = index;
vx[index] = i;
vy[index] = j;
index++;
}
int ks[k];
for (int i = 0; i < k; ++i) {
int x, y;
cin >> x >> y;
ks[i] = id[x - 1][y - 1];
}
int d[m * n][m * n];
int p[m * n][m * n];
for (int i = 0; i < index; ++i)
for (int j = 0; j < index; ++j) {
bool adjacent = (abs(vx[i] - vx[j]) + abs(vy[i] - vy[j])) == 1;
p[i][j] = -1;
if (adjacent) {
d[i][j] = a[vx[j]][vy[j]];
p[i][j] = i;
} else if (i == j)
d[i][i] = 0;
else
d[i][j] = 1e9;
}
for (int u = 0; u < index; ++u)
for (int i = 0; i < index; ++i)
for (int j = 0; j < index; ++j) {
int cost = d[i][u] + d[u][j];
if (cost < d[i][j]) {
p[i][j] = p[u][j];
d[i][j] = cost;
}
}
int dp[1 << k][m * n];
for (int i = 0; i < (1 << k); ++i)
for (int j = 0; j < index; ++j) dp[i][j] = 1e9;
for (int mask = 0; mask < (1 << k); ++mask) {
for (int v = 0; v < index; ++v) {
for (int i = 0; i < k; ++i)
if (ks[i] == v && (1 << i) == mask) dp[mask][v] = a[vx[v]][vy[v]];
for (int submask = mask; submask; submask = (submask - 1) & mask) {
int cost = dp[submask][v] + dp[mask ^ submask][v] - a[vx[v]][vy[v]];
if (cost < dp[mask][v]) dp[mask][v] = cost;
}
}
for (int v = 0; v < index; ++v)
for (int u = 0; u < index; ++u)
dp[mask][v] = min(dp[mask][v], dp[mask][u] + d[u][v]);
}
int min_v = 0;
for (int i = 0; i < index; ++i)
if (dp[(1 << k) - 1][i] < dp[(1 << k) - 1][min_v]) min_v = i;
cout << dp[(1 << k) - 1][min_v] << endl;
char b[n][m];
queue<pair<int, int> > path;
path.push(make_pair(min_v, (1 << k) - 1));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) b[i][j] = '.';
while (!path.empty()) {
pair<int, int> t = path.front();
int u = -1;
int mask = t.second;
int v = t.first;
path.pop();
for (int i = 0; i < index; ++i)
if (u == -1 ||
dp[mask][i] < dp[mask][u] && dp[mask][v] == dp[mask][i] + d[i][v])
u = i;
for (int j = v; j != u; j = p[u][j]) b[vx[j]][vy[j]] = 'X';
bool next = true;
for (int i = 0; i < k; ++i)
if (ks[i] == u && (1 << i) == mask) {
b[vx[u]][vy[u]] = 'X';
next = false;
}
if (next)
for (int submask = mask & (mask - 1); submask;
submask = (submask - 1) & mask)
if (dp[mask][u] ==
dp[submask][u] + dp[mask ^ submask][u] - a[vx[u]][vy[u]]) {
path.push(make_pair(u, submask));
path.push(make_pair(u, mask ^ submask));
break;
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) cout << b[i][j];
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 99999999;
int dp[210][1 << 8], pre[210][1 << 8];
queue<int> q;
int inq[210][1 << 8];
int val[110][110];
char s[110][110];
int n, m, k;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
void dfs(int pos, int st) {
int x = pos / m, y = pos % m;
s[x][y] = 'X';
if (pre[pos][st] == -1) return;
int ppos = pre[pos][st] / 1000, pst = pre[pos][st] % 1000;
dfs(ppos, pst);
if (pst != st) dfs(ppos, st - pst);
}
void update(int pos, int st, int v, int fa) {
if (v > dp[pos][st]) return;
dp[pos][st] = v;
pre[pos][st] = fa;
if (!inq[pos][st]) {
q.push(pos);
q.push(st);
inq[pos][st] = 1;
}
}
int main() {
int i, j, x, y, xx, yy, pos, st, now;
memset(inq, 0, sizeof(inq));
scanf("%d %d %d", &n, &m, &k);
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) {
s[i][j] = '.';
scanf("%d", &val[i][j]);
}
s[i][m] = '\0';
}
int tot = (1 << k);
for (i = 0; i < n * m; ++i)
for (j = 0; j < tot; ++j) dp[i][j] = inf;
for (i = 0; i < k; ++i) {
scanf("%d %d", &x, &y);
x--;
y--;
update(x * m + y, (1 << i), val[x][y], -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 = tot - 1 - st;
for (i = now; i; i = (i - 1) & now)
update(pos, st | i, dp[pos][st] + dp[pos][i] - val[x][y],
pos * 1000 + st);
}
int ans = inf, res = 0;
for (i = 0; i < n * m; ++i)
if (dp[i][tot - 1] < ans) {
res = i;
ans = dp[i][tot - 1];
}
dfs(res, tot - 1);
printf("%d\n", ans);
for (i = 0; i < n; ++i) printf("%s\n", s[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const long long BIG = 1446803456761533460LL;
const int Big = 336860180;
stringstream sss;
const int maxn = 210;
const int maxk = 7;
const int maxk2 = 1 << maxk;
int n, w, h, k;
int A[maxn];
int G[maxk];
int d[maxn][maxn];
bitset<maxn> di[maxn][maxn];
int dp[maxk2][maxn];
bitset<maxn> dpi[maxk2][maxn];
void MAIN() {
cin >> h >> w >> k;
for (int i = (0); i < (h); ++i) {
for (int j = (0); j < (w); ++j) {
cin >> A[i * w + j];
}
}
for (int i = (0); i < (k); ++i) {
int a, b;
cin >> a >> b;
G[i] = (a - 1) * w + (b - 1);
}
n = h * w;
memset(d, 20, sizeof d);
for (int i = (0); i < (h); ++i) {
for (int j = (0); j < (w); ++j) {
int x = i * w + j;
if (i > 0) {
d[x][x - w] = A[x] + A[x - w];
di[x][x - w][x] = di[x][x - w][x - w] = 1;
}
if (j > 0) {
d[x][x - 1] = A[x] + A[x - 1];
di[x][x - 1][x] = di[x][x - 1][x - 1] = 1;
}
if (i + 1 < h) {
d[x][x + w] = A[x] + A[x + w];
di[x][x + w][x] = di[x][x + w][x + w] = 1;
}
if (j + 1 < w) {
d[x][x + 1] = A[x] + A[x + 1];
di[x][x + 1][x] = di[x][x + 1][x + 1] = 1;
}
}
}
for (int i = (0); i < (n); ++i) {
d[i][i] = A[i];
di[i][i][i] = 1;
}
for (int k = (0); k < (n); ++k) {
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < (n); ++j) {
if (d[i][k] + d[k][j] - A[k] < d[i][j]) {
d[i][j] = d[i][k] + d[k][j] - A[k];
di[i][j] = di[i][k] | di[k][j];
}
}
}
}
memset(dp, 20, sizeof dp);
for (int i = (0); i < (k); ++i) {
for (int j = (0); j < (n); ++j) {
dp[1 << i][j] = d[j][G[i]];
dpi[1 << i][j] = di[j][G[i]];
}
}
int k2 = 1 << k;
for (int i = (1); i < (k2); ++i) {
for (int j = (0); j < (n); ++j) {
int mn = Big;
pair<int, int> mni;
for (int sub = (i - 1) & i; sub > 0; sub = (sub - 1) & i) {
for (int v = (0); v < (n); ++v) {
int val = dp[sub][v] + dp[i ^ sub][v] + d[j][v] - A[v] * 2;
if (val < mn) {
mn = val;
mni = {sub, v};
}
}
}
if (mn < dp[i][j]) {
dp[i][j] = mn;
dpi[i][j] = dpi[mni.first][mni.second] |
dpi[i ^ mni.first][mni.second] | di[j][mni.second];
}
}
}
int mni = 0;
for (int i = (0); i < (n); ++i) {
if (dp[k2 - 1][i] < dp[k2 - 1][mni]) {
mni = i;
}
}
cout << dp[k2 - 1][mni] << '\n';
for (int i = (0); i < (h); ++i) {
for (int j = (0); j < (w); ++j) {
cout << (dpi[k2 - 1][mni][i * w + j] ? 'X' : '.');
}
cout << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
sss << R"(
4 5 4
1 4 5 1 2
2 2 2 2 7
2 4 1 4 5
3 2 1 7 1
1 1
1 5
4 1
4 4
)";
MAIN();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
char ch;
bool v[111][111];
struct data {
int x1, y1, s1, x2, y2, s2;
void sv(int a, int b, int c, int d, int e, int f) {
x1 = a;
y1 = b;
s1 = c;
x2 = d;
y2 = e;
s2 = f;
}
} p[111][111][260];
int i, j, k, n, m, f[111][111][260], a[111][111], lim, c[111][111], ans, t,
q[2000001][2], l, r, x, y, num, ax, ay;
inline void update(int tx, int ty) {
if (tx < 1 || tx > n || ty < 1 || ty > m) return;
if (f[tx][ty][i | a[tx][ty]] > f[x][y][i] + c[x][y]) {
f[tx][ty][i | a[tx][ty]] = f[x][y][i] + c[x][y];
p[tx][ty][i | a[tx][ty]].sv(x, y, i, 0, 0, 0);
if (!v[tx][ty]) v[tx][ty] = 1, q[++r][0] = tx, q[r][1] = ty;
}
}
void dfs(int x, int y, int s) {
if (!x) return;
data w = p[x][y][s];
v[x][y] = 1;
dfs(w.x1, w.y1, w.s1);
dfs(w.x2, w.y2, w.s2);
}
int main() {
scanf("%d%d%d", &n, &m, &num);
lim = (1 << num);
l = r = 0;
memset(v, 0, sizeof(v));
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
scanf("%d", &c[i][j]);
a[i][j] = 0;
for (k = 0; k < lim; k++) f[i][j][k] = inf;
}
for (i = 1; i <= num; i++) {
scanf("%d%d", &j, &k);
a[j][k] = (1 << (i - 1));
q[++r][0] = j;
q[r][1] = k;
v[j][k] = 1;
f[j][k][a[j][k]] = 0;
p[j][k][a[j][k]].sv(0, 0, 0, 0, 0, 0);
}
while (l < r) {
x = q[++l][0];
y = q[l][1];
v[x][y] = 0;
for (i = 0; i < lim; i++)
for (j = 0; j < lim; j++)
if (f[x][y][i | j] > f[x][y][i] + f[x][y][j]) {
f[x][y][i | j] = f[x][y][i] + f[x][y][j];
p[x][y][i | j].sv(x, y, i, x, y, j);
}
for (i = 0; i < lim; i++) {
if (f[x][y][i] >= inf) continue;
update(x - 1, y);
update(x + 1, y);
update(x, y - 1);
update(x, y + 1);
}
}
for (i = 1, ans = inf; i <= n; i++)
for (j = 1; j <= m; j++)
if (ans > f[i][j][lim - 1] + c[i][j])
ans = f[i][j][lim - 1] + c[i][j], ax = i, ay = j;
memset(v, 0, sizeof(v));
dfs(ax, ay, lim - 1);
printf("%d\n", ans);
for (i = 1; i <= n; i++, puts(""))
for (j = 1; j <= m; j++) putchar(v[i][j] ? 'X' : '.');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
const int K = (1 << 10) + 10;
const int inf = 0x3f3f3f3f;
struct Edge {
int to, nxt;
} e[N << 2];
queue<int> q;
pair<int, int> pre[N][K];
int n, m, k, tot, head[N], a[N], ans[N], vis[N], f[N][K];
void Build(int x, int y) {
e[++tot].to = y;
e[tot].nxt = head[x];
head[x] = tot;
e[++tot].to = x;
e[tot].nxt = head[y];
head[y] = tot;
}
void bfs(int S) {
while (!q.empty()) {
int x = q.front();
q.pop();
vis[x] = 0;
for (int i = head[x]; i; i = e[i].nxt) {
int y = e[i].to;
if (f[y][S] > f[x][S] + a[y]) {
f[y][S] = f[x][S] + a[y];
pre[y][S] = make_pair(x, S);
if (!vis[y]) {
vis[y] = 1;
q.push(y);
}
}
}
}
}
void Print(int x, int y) {
ans[x] = 1;
if (!pre[x][y].second) {
return;
}
Print(pre[x][y].first, pre[x][y].second);
if (pre[x][y].second != y) {
Print(x, y ^ pre[x][y].second);
}
}
signed main() {
ios::sync_with_stdio(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[(i - 1) * m + j];
if (i != 1) {
Build((i - 1) * m + j, (i - 2) * m + j);
}
if (j != 1) {
Build((i - 1) * m + j, (i - 1) * m + j - 1);
}
if (i != n) {
Build((i - 1) * m + j, i * m + j);
}
if (j != m) {
Build((i - 1) * m + j, (i - 1) * m + j + 1);
}
}
}
int len = (1 << k) - 1;
for (int S = 0; S <= len; S++) {
for (int i = 1; i <= n * m; i++) {
f[i][S] = inf;
}
}
for (int i = 1; i <= k; i++) {
int x, y;
cin >> x >> y;
f[(x - 1) * m + y][1 << (i - 1)] = a[(x - 1) * m + y];
ans[(x - 1) * m + y] = 1;
}
for (int S = 1; S <= len; S++) {
for (int Sx = (S - 1) & S; Sx; Sx = (Sx - 1) & S) {
for (int i = 1; i <= n * m; i++) {
if (f[i][Sx] + f[i][S ^ Sx] - a[i] < f[i][S]) {
f[i][S] = f[i][Sx] + f[i][S ^ Sx] - a[i];
pre[i][S] = make_pair(i, Sx);
}
}
}
for (int i = 1; i <= n * m; i++) {
if (f[i][S] != inf) {
vis[i] = 1;
q.push(i);
}
}
bfs(S);
}
int Ans = inf, p = 0;
for (int i = 1; i <= n * m; i++) {
if (Ans > f[i][len]) {
p = i;
Ans = f[i][len];
}
}
cout << Ans << endl;
Print(p, len);
for (int i = 1; i <= n * m; i++) {
cout << (ans[i] ? 'X' : '.');
if (i % m == 0) {
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * power(a * a % md, b / 2, md) % md
: power(a * a % md, b / 2, md) % md));
}
const int xn = 2e2 + 10;
const int xm = -20 + 10;
const int sq = 320;
const int inf = 1e9 + 10;
const long long INF = 1e18 + 10;
const int mod = 998244353;
const int base = 257;
int n, m, k, a[xn], dp[1 << 7][xn];
bitset<xn> mark[1 << 7][xn];
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
void upd(int mask, int u, int v) {
if (dp[mask][u] + a[v] < dp[mask][v]) {
dp[mask][v] = dp[mask][u] + a[v];
mark[mask][v] = mark[mask][u];
mark[mask][v][v] = 1;
pq.push({dp[mask][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 mask = 1; mask < (1 << k); ++mask) {
for (int v = 0; v < n * m; ++v) {
for (int sub = (mask - 1) & mask; sub > 0; sub = (sub - 1) & mask) {
int d = dp[sub][v] + dp[mask ^ sub][v] - a[v];
if (d < dp[mask][v])
dp[mask][v] = d, mark[mask][v] = mark[sub][v] | mark[mask ^ sub][v];
}
pq.push({dp[mask][v], v});
}
while (!pq.empty()) {
int v = pq.top().second, d = pq.top().first;
pq.pop();
if (dp[mask][v] != d) continue;
if (0 <= v - m) upd(mask, v, v - m);
if (v + m < n * m) upd(mask, v, v + m);
if (0 < v % m) upd(mask, v, v - 1);
if (v % m < m - 1) upd(mask, 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 MOD = (int)1e9 + 7;
const int INF = 99999999;
using namespace std;
struct Node {
int x, y;
int cost;
int s;
Node() {}
Node(int x_, int y_, int cost_, int s_) : x(x_), y(y_), cost(cost_), s(s_) {}
};
int n, m, k;
int dp[105][105][1 << 7];
int vis[105][105][1 << 7];
int cost[105][105];
int st[105][105];
int used[105][105];
int dir[4][2] = {0, 1, 0, -1, 1, 0, -1, 0};
Node pre[105][105][1 << 7];
queue<Node> Q;
void spfa() {
while (!Q.empty()) {
Node n1 = Q.front();
Q.pop();
vis[n1.x][n1.y][n1.s] = 0;
for (int i = 0; i < 4; i++) {
int xx = n1.x + dir[i][0];
int yy = n1.y + dir[i][1];
if (xx >= 0 && xx < n && yy >= 0 && yy < m) {
int ss = n1.s | st[xx][yy];
int cc = dp[n1.x][n1.y][n1.s] + cost[xx][yy];
if (cc < dp[xx][yy][ss]) {
dp[xx][yy][ss] = cc;
pre[xx][yy][ss] = n1;
if (ss == n1.s && !vis[xx][yy][ss]) {
vis[xx][yy][ss] = 1;
Q.push(Node(xx, yy, cc, ss));
}
}
}
}
}
}
void set_used(Node t) {
used[t.x][t.y] = 1;
if (t.s == -1) return;
Node tt = pre[t.x][t.y][t.s];
set_used(tt);
if (tt.x == t.x && tt.y == t.y) {
tt.s = (t.s - tt.s) | st[t.x][t.y];
set_used(tt);
}
}
int main() {
while (~scanf("%d%d%d", &n, &m, &k)) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &cost[i][j]);
memset(pre, -1, sizeof(pre));
memset(st, 0, sizeof(st));
memset(used, 0, sizeof(used));
memset(vis, 0, sizeof(vis));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int s = 0; s < (1 << k); s++) dp[i][j][s] = INF;
int sx, sy;
int x, y;
for (int i = 0; i < k; i++) {
scanf("%d%d", &x, &y);
x--, y--;
if (i == 0) sx = x, sy = y;
dp[x][y][1 << i] = cost[x][y];
st[x][y] = 1 << i;
}
int top = 1 << k;
for (int i = 1; i < top; i++) {
for (int x = 0; x < n; x++) {
for (int y = 0; y < m; y++) {
if (st[x][y] && !(i & st[x][y])) continue;
for (int sub = i & (i - 1); sub; sub = (sub - 1) & i) {
if (dp[x][y][i] > dp[x][y][sub | st[x][y]] +
dp[x][y][(i - sub) | st[x][y]] - cost[x][y]) {
dp[x][y][i] = dp[x][y][sub | st[x][y]] +
dp[x][y][(i - sub) | st[x][y]] - cost[x][y];
pre[x][y][i] = Node(x, y, 0, sub | st[x][y]);
}
}
if (dp[x][y][i] < INF) {
vis[x][y][i] = 1;
Q.push(Node(x, y, dp[x][y][i], i));
}
}
}
spfa();
}
printf("%d\n", dp[sx][sy][top - 1]);
set_used(Node(sx, sy, 0, top - 1));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (used[i][j])
printf("X");
else
printf(".");
}
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int k;
int esp[10];
int dist[210][210];
int l, c;
int M[210][210];
int pai[210][210];
int pd[210][210][2];
int Vx[] = {-1, 1, 0, 0};
int Vy[] = {0, 0, -1, 1};
int C[210];
bool resp[210];
bool submask(int a, int b) {
for (int i = 0; i < k; i++)
if (!((a >> i) & 1) && ((b >> i) & 1)) return false;
return true;
}
void desenha(int x, int y) {
resp[x] = resp[y] = true;
if (x == y) return;
int p = pai[x][y];
if (p == -1) return;
desenha(x, p), desenha(p, y);
}
int solve(int mask, int v, int flag);
int monta(int mask, int v, int flag) {
int qnts = 0, quem;
int ret;
for (int i = 0; i < k; i++)
if ((mask >> i) & 1) qnts++, quem = i;
if (qnts == 1) {
desenha(esp[quem], v);
return ret = dist[esp[quem]][v] + C[esp[quem]];
}
ret = 100000000;
if (flag) {
for (int i = 1; i < (1 << k) - 1; i++)
if (submask(mask, i)) {
int x = solve(i, v, 0) + solve(mask ^ i, v, 0) - C[v];
if (ret > x) {
ret = x, quem = i;
}
}
monta(quem, v, 0), monta(mask ^ quem, v, 0);
return ret;
}
for (int i = 0; i < n; i++) {
int x = solve(mask, i, 1) + dist[i][v];
if (ret > x) {
ret = x;
quem = i;
}
}
desenha(quem, v);
monta(mask, quem, 1);
return ret;
}
int solve(int mask, int v, int flag) {
if (mask == 0) return C[v];
int& ret = pd[mask][v][flag];
if (ret != -1) return ret;
int qnts = 0, quem;
for (int i = 0; i < k; i++)
if ((mask >> i) & 1) qnts++, quem = i;
if (qnts == 1) {
return ret = dist[esp[quem]][v] + C[esp[quem]];
}
ret = 100000000;
if (flag) {
for (int i = 1; i < (1 << k) - 1; i++)
if (submask(mask, i)) {
if (i == mask || (mask ^ i) == mask) continue;
ret = min(ret, solve(i, v, 0) + solve(mask ^ i, v, 0) - C[v]);
}
return ret;
}
for (int i = 0; i < n; i++) ret = min(ret, solve(mask, i, 1) + dist[i][v]);
return ret;
}
int converte(int a, int b) { return a * c + b; }
void floyd() {
memset(pai, -1, sizeof(pai));
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
if (dist[i][j] > dist[i][k] + dist[k][j]) {
dist[i][j] = dist[i][k] + dist[k][j];
pai[i][j] = k;
}
}
}
int main() {
scanf("%d %d %d", &l, &c, &k);
n = l * c;
for (int i = 0; i < l; i++)
for (int j = 0; j < c; j++) cin >> M[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) dist[i][j] = 100000000;
for (int i = 0; i < n; i++) dist[i][i] = 0;
for (int i = 0; i < l; i++)
for (int j = 0; j < c; j++) C[converte(i, j)] = M[i][j];
for (int i = 0; i < l; i++)
for (int j = 0; j < c; j++) {
int v = converte(i, j);
for (int t = 0; t < 4; t++) {
int x = i + Vx[t], y = j + Vy[t];
if (x < 0 || y < 0 || x >= l || y >= c) continue;
int u = converte(x, y);
dist[v][u] = C[u];
}
}
int topo = 0;
for (int i = 0; i < k; i++) {
int x, y;
scanf("%d %d", &x, &y);
esp[topo++] = converte(x - 1, y - 1);
}
floyd();
memset(pd, -1, sizeof(pd));
int ans = 100000000;
int menor;
for (int i = 0; i < n; i++) {
int x = solve((1 << k) - 1, i, 1);
if (ans > x) {
ans = x;
menor = i;
}
}
cout << ans << endl;
char cc;
monta((1 << k) - 1, menor, 1);
for (int i = 0; i < l; i++) {
for (int j = 0; j < c; j++) {
if (resp[i * c + j])
cc = 'X';
else
cc = '.';
printf("%c", cc);
}
printf("\n");
}
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>
const int N = 110;
const int dx[] = {-1, 0, 0, 1};
const int dy[] = {0, -1, 1, 0};
const int INF = 0x3f3f3f3f;
int a[N][N];
int pre[N][N][1 << 7][3];
int dp[N][N][1 << 7];
int x[10], y[10];
int map[110][110];
void GetAns(int x, int y, int mask) {
map[x][y] = 1;
if (pre[x][y][mask][0] == 0) {
GetAns(pre[x][y][mask][1], pre[x][y][mask][2], mask);
} else if (pre[x][y][mask][0] == 1) {
GetAns(x, y, pre[x][y][mask][1]);
GetAns(x, y, pre[x][y][mask][2]);
}
}
int main() {
int n, m, 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]);
memset(dp, 0x3f, sizeof(dp));
for (int i = 0; i < k; ++i) {
scanf("%d%d", &x[i], &y[i]);
--x[i], --y[i];
dp[x[i]][y[i]][1 << i] = a[x[i]][y[i]];
pre[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 submask = mask; submask; submask = (submask - 1) & mask)
if (dp[i][j][submask] + dp[i][j][mask ^ submask] - a[i][j] <
dp[i][j][mask]) {
dp[i][j][mask] =
dp[i][j][submask] + dp[i][j][mask ^ submask] - a[i][j];
pre[i][j][mask][0] = 1;
pre[i][j][mask][1] = submask;
pre[i][j][mask][2] = mask ^ submask;
}
for (int t = 0; t < n * m; ++t)
for (int x = 0; x < n; ++x)
for (int y = 0; y < m; ++y)
for (int i = 0; i < 4; ++i) {
int _x = x + dx[i];
int _y = y + dy[i];
if (_x >= 0 && _x < n && _y >= 0 && _y < m) {
if (dp[_x][_y][mask] + a[x][y] < dp[x][y][mask]) {
dp[x][y][mask] = dp[_x][_y][mask] + a[x][y];
pre[x][y][mask][0] = 0;
pre[x][y][mask][1] = _x;
pre[x][y][mask][2] = _y;
}
}
}
}
int ans = INF;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) ans = std::min(ans, dp[i][j][(1 << k) - 1]);
printf("%d\n", ans);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (dp[i][j][(1 << k) - 1] == ans) {
GetAns(i, j, (1 << k) - 1);
for (int x = 0; x < n; ++x) {
for (int y = 0; y < m; ++y)
if (map[x][y])
putchar('X');
else
putchar('.');
printf("\n");
}
return 0;
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int N = 2e2 + 10;
const long long mod = 1e9 + 7;
const long long mod2 = 998244353;
const long long inf = 1e18;
const int LOG = 8;
long long pw(long long a, long long b, long long M) {
return (!b ? 1
: (b & 1 ? (a * pw(a * a % M, b / 2, M)) % M
: pw(a * a % M, b / 2, M)));
}
struct node {
int n, m, k, A[N][N], V[LOG], B[N];
long long dis[LOG][N], dp[1 << LOG][N];
vector<int> G[N];
int id(int i, int j) { return (i - 1) * m + j; }
void dij(int id, int St) {
for (int i = 1; i <= n * m; i++) {
dis[id][i] = inf;
}
dis[id][St] = B[St];
set<pair<long long, long long> > st;
st.insert(make_pair(dis[id][St], St));
while ((int)st.size()) {
int v = st.begin()->second;
st.erase(st.begin());
for (auto u : G[v]) {
if (dis[id][u] > dis[id][v] + B[u]) {
dis[id][u] = dis[id][v] + B[u];
st.insert(make_pair(dis[id][u], u));
}
}
}
}
node(int _n, int _m, int _k, int B2[], pair<int, int> E[]) {
n = _n, m = _m, k = _k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
B[id(i, j)] = B2[(i - 1) * m + j - 1];
if (i < n) {
G[id(i, j)].push_back(id(i + 1, j));
G[id(i + 1, j)].push_back(id(i, j));
}
if (j < m) {
G[id(i, j)].push_back(id(i, j + 1));
G[id(i, j + 1)].push_back(id(i, j));
}
}
}
for (int i = 0; i < k; i++) {
int x, y;
x = E[i].first, y = E[i].second;
V[i] = id(x, y);
dij(i, V[i]);
}
for (int i = 1; i <= n * m; i++) {
dp[0][i] = B[i];
}
long long tot = inf;
for (int mask = 1; mask < 1 << k; mask++) {
for (int i = 1; i <= n * m; i++) {
dp[mask][i] = inf;
}
set<pair<long long, long long> > st;
for (int i = 1; i <= n * m; i++) {
for (int j = 0; j < k; j++) {
if (mask >> j & 1) {
dp[mask][i] =
min(dp[mask][i], dp[mask ^ (1 << j)][i] +
(i == V[j] ? 0 : dis[j][i] - B[i]));
}
}
st.insert(make_pair(dp[mask][i], i));
}
while ((int)st.size()) {
int v = st.begin()->first;
st.erase(st.begin());
for (auto u : G[v]) {
if (dp[mask][u] > dp[mask][v] + B[u]) {
dp[mask][u] = dp[mask][v] + B[u];
st.insert(make_pair(dp[mask][u], u));
}
}
}
if (mask + 1 == (1 << k)) {
for (int i = 1; i <= n * m; i++) {
tot = min(tot, dp[mask][i]);
}
}
}
cout << tot << endl;
}
};
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;
pair<int, int> Aria[N];
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;
Aria[i] = make_pair(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] << endl;
for (int i = 0; i < n; i++, cout << endl)
for (int j = 0; j < m; j++)
cout << (mark[(1 << k) - 1][v][i * m + j] ? 'X' : '.');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool vis[205];
int n, m, k, st[10], id[205][205], mp[205], val[205], ans[205], Q[1 << 14 | 5],
dp[205][1 << 7 | 5];
struct node {
int u, S;
} pre[205][1 << 7 | 5];
bool chkmin(int &x, int y) { return x > y ? x = y, 1 : 0; }
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
void spfa(int S, int l, int r) {
while (l <= r) {
int u = Q[l++];
int x = u / m, y = u % m;
vis[u] = 0;
for (int i = 0; i < 4; i++) {
int tx = x + dx[i], ty = y + dy[i];
if (tx < 0 || ty < 0 || tx == n || ty == m) continue;
int v = id[tx][ty], T = val[v] ? S : S | 1 << mp[v];
if (chkmin(dp[v][T], dp[u][S] + val[v])) {
if (S == T && !vis[v]) {
Q[++r] = v, vis[v] = 1;
}
pre[v][T] = node{u, S};
}
}
}
}
void print(int u, int S) {
node tmp = pre[u][S];
if (!tmp.u && !tmp.S) return;
ans[tmp.u] = 1;
if (u == tmp.u) {
print(u, S ^ tmp.S);
}
print(tmp.u, tmp.S);
}
int main() {
int tpas = 0;
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int &x = id[i][j];
x = i * m + j;
scanf("%d", &val[x]);
}
}
for (int i = 0; i < k; i++) {
int x, y;
scanf("%d %d", &x, &y);
int t = id[x - 1][y - 1];
tpas += val[t], val[t] = 0, mp[t] = i, st[i] = t;
}
if (k == n * m) {
printf("%d\n", tpas);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
putchar('X');
}
puts("");
}
return 0;
}
int all = (1 << k) - 1;
memset(dp, 0x3f, sizeof dp);
for (int i = 0; i < k; i++) {
dp[st[i]][1 << i] = 0;
}
for (int S = 1; S <= all; S++) {
int l = 1, r = 0;
for (int i = 0; i < n * m; i++) {
for (int sub = S; sub; sub = (sub - 1) & S) {
if (chkmin(dp[i][S], dp[i][sub] + dp[i][S ^ sub] - val[i])) {
pre[i][S] = node{i, sub};
}
}
if (dp[i][S] < 1e9) Q[++r] = i, vis[i] = 1;
}
spfa(S, l, r);
}
int res = 1 << 30, rt = -1;
for (int i = 0; i < id[n - 1][m - 1]; i++) {
if (chkmin(res, dp[i][all])) rt = i;
}
print(rt, all);
printf("%d\n", res + tpas);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int x = id[i][j];
if (!val[x]) {
putchar('X');
} else {
putchar(ans[x] ? 'X' : '.');
}
}
putchar(10);
}
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 = 0; 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 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; }
template <typename T>
inline void read(T& 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;
int n, m, k, nm, a, b;
int flor[201];
int pd[1 << 7][201];
int pai[1 << 7][201];
bool mark[201];
int di[4] = {1, 0, -1, 0};
int dj[4] = {0, 1, 0, -1};
int sub[4];
char sai[102];
void make(int mask, int at) {
mark[at] = true;
int pmask = pai[mask][at];
if (pmask < 0) return;
int pat = pmask & 0xFFFF;
pmask >>= 16;
make(pmask, pat);
if (pmask != mask) make(mask ^ pmask, at);
}
int main() {
scanf("%d %d %d", &n, &m, &k);
nm = n * m;
sub[0] = m;
sub[1] = 1;
sub[2] = -m;
sub[3] = -1;
for (int i = 0; i < nm; ++i) {
scanf("%d", flor + i);
}
memset(pd, 63, sizeof pd);
for (int i = 0; i < k; ++i) {
scanf("%d %d", &a, &b);
--a, --b;
a = a * m + b;
pd[1 << i][a] = flor[a];
pai[1 << i][a] = -1;
}
int mask = 1 << k, c;
for (int i = 1; i < mask; ++i) {
for (int j = 0; j < nm; ++j) {
b = 1 << 30;
for (int i2 = (i - 1) & i; i2; i2 = (i2 - 1) & i) {
a = pd[i2][j] + pd[i ^ i2][j] - flor[j];
if (a < b) {
b = a;
c = i2;
}
}
if (b < pd[i][j]) {
pd[i][j] = b;
pai[i][j] = (c << 16) + j;
}
}
queue<int> fila;
memset(mark, 0, nm);
for (int j = 0; j < nm; ++j) fila.push(j);
while (fila.size()) {
a = fila.front();
fila.pop();
mark[a] = true;
for (int z = 0; z < 4; ++z) {
int ii = a / m + di[z];
int jj = a % m + dj[z];
if (ii >= 0 && ii < n && jj >= 0 && jj < m) {
int nxt = a + sub[z];
b = pd[i][a] + flor[nxt];
if (b < pd[i][nxt]) {
pai[i][nxt] = (i << 16) + a;
pd[i][nxt] = b;
if (mark[nxt]) {
mark[nxt] = false;
fila.push(nxt);
}
}
}
}
}
}
--mask;
a = 1 << 30;
b = 0;
for (int i = 0; i < nm; ++i) {
if (pd[mask][i] < a) {
a = pd[mask][i];
b = i;
}
}
printf("%d\n", a);
memset(mark, 0, nm);
make(mask, b);
b = 0;
for (int i = 0; i < n; ++i, b += m) {
for (int j = 0; j < m; ++j) {
sai[j] = mark[b + j] ? 'X' : '.';
}
printf("%s\n", sai);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int di[] = {-1, 1, 0, 0};
const int dj[] = {0, 0, -1, 1};
const int oo = 1000111000;
int a[111][111], m, n;
struct State {
int mask, u, v;
State() {}
State(int u, int v, int mask) : u(u), v(v), mask(mask) {}
};
bool operator<(const State &a, const State &b) {
if (a.mask != b.mask) return a.mask < b.mask;
if (a.u != b.u) return a.u < b.u;
return a.v < b.v;
}
bool outside(int u, int v) {
if (u < 1 || v < 1 || u > m || v > n) return true;
return false;
}
set<pair<int, State> > s;
int f[111][111][222], mark[111][111];
State tr[111][111][222], tr2[111][111][222];
char res[111][111];
void trace(State cur) {
if (cur.mask == 0) return;
res[cur.u][cur.v] = 'X';
trace(tr[cur.u][cur.v][cur.mask]);
if (tr2[cur.u][cur.v][cur.mask].mask >= 0) {
trace(tr2[cur.u][cur.v][cur.mask]);
}
}
int main() {
int k;
scanf("%d%d%d", &m, &n, &k);
for (int i = (1), _b = (m); i <= _b; i++)
for (int j = (1), _b = (n); j <= _b; j++) scanf("%d", &a[i][j]);
for (int i = (1), _b = (m); i <= _b; i++)
for (int j = (1), _b = (n); j <= _b; j++)
for (int mask = 0, _a = ((1 << (k))); mask < _a; mask++)
f[i][j][mask] = oo;
for (int i = (1), _b = (k); i <= _b; i++) {
int u, v;
scanf("%d%d", &u, &v);
mark[u][v] = i;
f[u][v][(1 << (i - 1))] = a[u][v];
s.insert(make_pair(a[u][v], State(u, v, (1 << (i - 1)))));
}
while (!s.empty()) {
State cur = s.begin()->second;
int l = s.begin()->first;
s.erase(s.begin());
if (f[cur.u][cur.v][cur.mask] != l) continue;
if (cur.mask == (1 << (k)) - 1) {
printf("%d\n", l);
memset(res, '.', sizeof res);
trace(cur);
for (int i = (1), _b = (m); i <= _b; i++) {
for (int j = (1), _b = (n); j <= _b; j++) printf("%c", res[i][j]);
puts("");
}
return 0;
}
State next;
for (int dir = 0, _a = (4); dir < _a; dir++) {
next.u = cur.u + di[dir];
next.v = cur.v + dj[dir];
if (outside(next.u, next.v)) continue;
if (mark[next.u][next.v])
next.mask = cur.mask | (1 << (mark[next.u][next.v] - 1));
else
next.mask = cur.mask;
int cost = f[cur.u][cur.v][cur.mask] + a[next.u][next.v];
if (f[next.u][next.v][next.mask] > cost) {
f[next.u][next.v][next.mask] = cost;
tr[next.u][next.v][next.mask] = cur;
tr2[next.u][next.v][next.mask] = State(0, 0, -1);
s.insert(make_pair(cost, next));
}
for (int mask2 = 0, _a = ((1 << (k))); mask2 < _a; mask2++)
if (mask2)
if ((mask2 & next.mask) == 0) {
State savenext = next;
next.mask = mask2 | next.mask;
cost = f[cur.u][cur.v][cur.mask] + f[next.u][next.v][mask2];
if (f[next.u][next.v][next.mask] > cost) {
f[next.u][next.v][next.mask] = cost;
s.insert(make_pair(cost, next));
tr[next.u][next.v][next.mask] = cur;
tr2[next.u][next.v][next.mask] = State(next.u, next.v, mask2);
}
next = savenext;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
int min(int a, int b) { return a < b ? a : b; }
typedef struct {
int c, p, a, b;
} result;
result r[1 << 7][100][100];
char b[100][100];
void backtrace(int mask, int i, int j) {
b[i][j] = 'X';
result c = r[mask][i][j];
if (c.p == 1) {
backtrace(c.a, i, j);
backtrace(c.b, i, j);
} else if (c.p == 2)
backtrace(mask, c.a, c.b);
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
int a[100][100];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &a[i][j]);
const int inf = 1000000000;
for (int mask = 0; mask < 1 << k; mask++)
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) r[mask][i][j].c = inf;
for (int i = 0; i < k; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
r[1 << i][x][y] = (result){a[x][y], 0, 0, 0};
}
for (int mask = 0; 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 c = r[submask][i][j].c + r[mask ^ submask][i][j].c - a[i][j];
if (c < r[mask][i][j].c)
r[mask][i][j] = (result){c, 1, submask, mask ^ submask};
}
}
for (int l = 0; l < n * m; l++)
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
for (int di = 0; di < 4; di++) {
int ii = i + (int[]){1, 0, -1, 0}[di],
jj = j + (const int[]){0, 1, 0, -1}[di];
if (0 <= ii && ii < n && 0 <= jj && jj < m) {
int c = r[mask][i][j].c + a[ii][jj];
if (c < r[mask][ii][jj].c) r[mask][ii][jj] = (result){c, 2, i, j};
}
}
}
}
int mc = inf, mi, mj;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int c = r[(1 << k) - 1][i][j].c;
if (c < mc) {
mc = c;
mi = i;
mj = j;
}
}
memset(b, '.', sizeof(b));
backtrace((1 << k) - 1, mi, mj);
printf("%d\n", mc);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) putchar(b[i][j]);
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (1 << 29);
const int N = 105, M = 105, NM = 205, K = 8;
int n, m, k, a[N][M], x[NM], y[NM], dp[1 << K][NM], dist[NM][NM],
dist_parent[NM][NM];
pair<int, bool> dp_parent[1 << K][NM];
char result[N][M];
void construct_path(int i, int j) {
if (dist_parent[i][j] == -1) {
result[x[i]][y[i]] = 'X';
result[x[j]][y[j]] = 'X';
} else {
int p = dist_parent[i][j];
construct_path(i, p);
construct_path(p, j);
}
}
void construct_set(int i, int j) {
if (dp_parent[i][j].first == -1) {
for (int h = 0; h < k; h++)
if (i & (1 << h)) {
construct_path(h, j);
}
} else {
pair<int, bool> p = dp_parent[i][j];
if (p.second) {
construct_set(p.first, j);
construct_set(i & ~p.first, j);
} else {
construct_set(i, p.first);
construct_path(p.first, j);
}
}
}
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]--;
}
int c = k;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
bool flag = true;
for (int a = 0; a < k; a++)
if (i == x[a] && j == y[a]) flag = false;
if (flag) {
x[c] = i;
y[c] = j;
c++;
}
}
for (int i = 0; i < c; i++)
for (int j = 0; j < c; j++) {
if (i != j && ((abs(x[i] - x[j]) + abs(y[i] - y[j]) == 1))) {
dist[i][j] = a[x[j]][y[j]];
} else {
dist[i][j] = inf;
}
dist_parent[i][j] = -1;
}
for (int i = 0; i < c; i++) dist[i][i] = 0;
for (int i = 0; i < c; i++)
for (int j = 0; j < c; j++)
for (int k = 0; k < c; k++) {
int new_dist = dist[j][i] + dist[i][k];
if (new_dist < dist[j][k]) {
dist[j][k] = new_dist;
dist_parent[j][k] = i;
}
}
for (int i = 0; i < c; i++)
for (int j = 0; j < c; j++)
if (i != j) dist[i][j] -= a[x[j]][y[j]];
for (int i = 0; i < 1 << k; i++) {
if (i) {
for (int j = 0; j < c; j++) {
for (int h = 0; h < k; h++)
if (i & (1 << h)) dp[i][j] += a[x[h]][y[h]] + dist[h][j];
if (!(j < k && (i & (1 << j)))) dp[i][j] += a[x[j]][y[j]];
dp_parent[i][j].first = -1;
for (int g = i; g; g = (g - 1) & i)
if (g && (i & ~g)) {
int new_v = dp[g][j] + dp[i & ~g][j] - a[x[j]][y[j]];
if (new_v < dp[i][j]) {
dp[i][j] = new_v;
dp_parent[i][j] = make_pair(g, true);
}
}
}
for (int j = 0; j < c; j++) {
for (int k = 0; k < c; k++) {
int new_v = dp[i][j] + dist[j][k] + a[x[k]][y[k]];
if (new_v < dp[i][k]) {
dp[i][k] = new_v;
dp_parent[i][k] = make_pair(j, false);
}
}
}
} else {
for (int j = 0; j < c; j++) dp[i][j] = 0;
}
}
int best = 0;
for (int j = 0; j < c; j++)
if (dp[(1 << k) - 1][j] < dp[(1 << k) - 1][best]) best = j;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) result[i][j] = '.';
cout << dp[(1 << k) - 1][best] << endl;
construct_set((1 << k) - 1, best);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << result[i][j];
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, a[201], b[9], d[201][201], dp[1 << 7][201];
pair<int, int> pre[1 << 7][201];
char ans[101][101];
int f(int S, int p) {
int& res = dp[S][p];
if (res > -1) return res;
for (int i = 0; i < k; i++)
if (S == (1 << i)) {
if (b[i] == p) return res = a[p];
}
res = 1000000007LL;
pair<int, int>& pr = pre[S][p];
for (int T = (S - 1) & S; T > 0; T = (T - 1) & S) {
int c = f(T, p) + f(T ^ S, p) - a[p];
if (c < res) {
res = c;
pr = make_pair(T, p);
}
}
for (int i = 0; i < n * m; i++)
if (i != p) {
int c = f(S, i) + d[p][i] - a[i];
if (c < res) {
res = c;
pr = make_pair(S, i);
}
}
return res;
}
int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
int id(int x, int y) { return x * m + y; }
void draw(int cur, int to) {
ans[cur / m][cur % m] = 'X';
if (cur == to) return;
int x = cur / m, y = cur % m;
for (int i = 0; i < 4; i++) {
int nx = x + dx[i], ny = y + dy[i];
if (0 <= nx && nx < n && 0 <= ny && ny < m &&
a[cur] + d[id(nx, ny)][to] == d[cur][to]) {
draw(id(nx, ny), to);
break;
}
}
}
void g(int S, int p) {
pair<int, int> P = pre[S][p];
if (P.first == -1) {
draw(p, p);
return;
}
if (p != P.first) draw(p, P.second);
g(P.first, P.second);
if (P.first != S) g(S ^ P.first, p);
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n * m; i++) cin >> a[i];
for (int i = 0; i < k; i++) {
int x, y;
cin >> x >> y;
b[i] = id(x - 1, y - 1);
}
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++) d[i][j] = 1000000007LL;
for (int i = 0; i < n * m; i++) d[i][i] = 0;
for (int i = 0; i < n - 1; i++)
for (int j = 0; j < m; j++) {
d[id(i, j)][id(i + 1, j)] = a[id(i + 1, j)];
d[id(i + 1, j)][id(i, j)] = a[id(i, j)];
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m - 1; j++) {
d[id(i, j)][id(i, j + 1)] = a[id(i, j + 1)];
d[id(i, j + 1)][id(i, j)] = a[id(i, j)];
}
for (int ii = 0; ii < n * m; ii++)
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][ii] + d[ii][j]);
}
memset(dp, -1, sizeof(dp));
memset(pre, -1, sizeof(pre));
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++) d[i][j] += a[i];
cout << f((1 << k) - 1, b[0]) << endl;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) ans[i][j] = '.';
g((1 << k) - 1, b[0]);
for (int i = 0; i < n; i++) cout << ans[i] << endl;
}
|
#include <bits/stdc++.h>
const int MAXN = 105;
const int INF = 1000000000;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
struct Node {
int c, op, i, j;
Node() { c = INF; }
Node(int c, int op, int i, int j) : c(c), op(op), i(i), j(j) {}
} dp[1 << 7][MAXN][MAXN];
int c[MAXN][MAXN];
char map[MAXN][MAXN];
void build(int sub, int i, int j) {
map[i][j] = 'X';
if (dp[sub][i][j].op == 0) return;
if (dp[sub][i][j].op == 1) {
build(dp[sub][i][j].i, i, j);
build(dp[sub][i][j].j, i, j);
} else
build(sub, dp[sub][i][j].i, dp[sub][i][j].j);
}
int main() {
int n, m, p, i, j, k;
scanf("%d%d%d", &n, &m, &p);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
scanf("%d", &c[i][j]);
map[i][j] = '.';
}
int x, y;
for (i = 0; i < p; i++) {
scanf("%d%d", &x, &y);
dp[1 << i][x][y] = Node(c[x][y], 1, 0, 0);
}
int mark = 1 << p;
int nn = n * m;
for (i = 0; i < mark; i++) {
for (j = 1; j <= n; j++)
for (k = 1; k <= m; k++)
for (int sub = i; sub; sub = i & (sub - 1))
if (dp[i][j][k].c > dp[sub][j][k].c + dp[i ^ sub][j][k].c - c[j][k])
dp[i][j][k] = Node(dp[sub][j][k].c + dp[i ^ sub][j][k].c - c[j][k],
1, sub, i ^ sub);
for (int L = 0; L < nn; L++)
for (j = 1; j <= n; j++)
for (k = 1; k <= m; k++)
for (int dir = 0; dir < 4; dir++) {
int fx = j + dx[dir];
int fy = k + dy[dir];
if (fx == 0 || fx > n || fy == 0 || fy > m) continue;
if (dp[i][fx][fy].c > dp[i][j][k].c + c[fx][fy])
dp[i][fx][fy] = Node(dp[i][j][k].c + c[fx][fy], 2, j, k);
}
}
int ans = INF, ti, tj;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (ans > dp[mark - 1][i][j].c) {
ans = dp[mark - 1][i][j].c;
ti = i;
tj = j;
}
printf("%d\n", ans);
build(mark - 1, ti, tj);
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) printf("%c", map[i][j]);
printf("\n");
}
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];
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, int val) {
s[pos / m][pos % m] = 'X';
for (int xx = msk; xx; xx = (xx - 1) & msk) {
if (xx == msk) continue;
if (dp[pos][xx] + dp[pos][msk ^ xx] - a[pos] == val) {
cover(xx, pos, dp[pos][xx]);
cover(msk ^ xx, pos, dp[pos][msk ^ xx]);
return;
}
}
for (int ppos = 0; ppos < n * m; ppos++) {
if (ppos == pos) continue;
if (dp[ppos][msk] + dis[pos][ppos] - a[ppos] == val) {
cover2(pos, ppos);
cover(msk, ppos, dp[ppos][msk]);
return;
}
}
int cnt = 0;
for (int i = 0; i < k; i++)
if (msk >> i & 1) cnt++;
if (cnt == 1) {
for (int i = 0; i < k; i++)
if (msk >> i & 1) cover2(pos, po[i]);
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
s[i].resize(m);
for (int j = 0; j < m; j++) s[i][j] = '.';
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i * m + j];
floyd();
po.resize(k);
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);
for (int pos = 0; pos < n * m; pos++) dp[pos][1 << i] = dis[po[i]][pos];
}
for (int i = 0; i < (1 << k); i++) {
for (int pos = 0; pos < n * m; pos++)
for (int ppos = 0; ppos < n * m; ppos++)
dp[ppos][i] = min(dp[ppos][i], dp[pos][i] + dis[pos][ppos] - a[pos]);
for (int pos = 0; pos < n * m; pos++)
if (dp[pos][i] < 0x3f3f3f3f) {
for (int ii = 0; ii < (1 << k); ii++) {
dp[pos][i | ii] =
min(dp[pos][i | ii], dp[pos][i] + dp[pos][ii] - a[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, ans);
cout << ans << endl;
for (int i = 0; i < n; i++) {
cout << s[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct fastIO {
inline fastIO operator>>(int& num) {
num = 0;
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
bool foo = 0;
if (c == '-') {
foo = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
if (foo) num = -num;
return *this;
}
inline fastIO operator>>(long long& num) {
num = 0;
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
bool foo = 0;
if (c == '-') {
foo = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
if (foo) num = -num;
return *this;
}
inline fastIO operator>>(float& num) {
scanf("%f", &num);
return *this;
}
inline fastIO operator>>(double& num) {
scanf("%lf", &num);
return *this;
}
inline fastIO operator>>(long double& num) {
scanf("%Lf", &num);
return *this;
}
inline fastIO operator>>(char& num) {
num = getchar();
while (num == ' ' || num == '\n') num = getchar();
return *this;
}
inline fastIO operator>>(char* num) {
int cnt = 0;
char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
while (c != ' ' && c != '\n') {
num[cnt++] = c;
c = getchar();
}
num[cnt] = 0;
return *this;
}
inline fastIO operator>>(string& num) {
cin >> num;
return *this;
}
inline void printInt(const int& num) {
if (num < 10) {
putchar(num + '0');
return;
}
printInt(num / 10);
putchar((num % 10) + '0');
}
inline void printINT(const long long& num) {
if (num < 10) {
putchar(num + '0');
return;
}
printINT(num / 10);
putchar((num % 10) + '0');
}
inline fastIO operator<<(const int& num) {
if (num < 0)
putchar('-'), printInt(-num);
else
printInt(num);
return *this;
}
inline fastIO operator<<(const long long& num) {
if (num < 0)
putchar('-'), printINT(-num);
else
printINT(num);
return *this;
}
inline fastIO operator<<(const float& num) {
printf("%.10f", num);
return *this;
}
inline fastIO operator<<(const double& num) {
printf("%.16lf", num);
return *this;
}
inline fastIO operator<<(const long double& num) {
printf("%.20Lf", num);
return *this;
}
inline fastIO operator<<(const char& num) {
putchar(num);
return *this;
}
inline fastIO operator<<(const char* num) {
for (int i = 0; num[i]; i++) putchar(num[i]);
return *this;
}
inline fastIO operator<<(const string& num) {
cout << num;
return *this;
}
} fio;
int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
int n, m, k;
int fl[205];
int dp[(1 << (7)) + 5][205];
pair<int, int> go[(1 << (7)) + 5][205];
int X[10], Y[10];
char ans[205];
bool lgl[205];
inline int code(int x, int y) { return x * m + y; }
void dfs(int x, int y) {
ans[y] = 'X';
if (go[x][y].second == y) {
if (go[x][y].first) {
dfs(go[x][y].first, go[x][y].second);
dfs(x ^ go[x][y].first, go[x][y].second);
}
} else {
if (go[x][y].first) {
dfs(go[x][y].first, go[x][y].second);
}
}
}
int main() {
fio >> n >> m >> k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
fio >> fl[code(i, j)];
}
}
memset((void*)dp, 0x3f, sizeof(dp));
for (int i = 0; i < k; i++) {
fio >> X[i] >> Y[i];
X[i]--;
Y[i]--;
dp[(1 << (i))][code(X[i], Y[i])] = fl[code(X[i], Y[i])];
}
for (int i = 1; i < (1 << (k)); i++) {
queue<int> q;
memset((void*)lgl, 0, sizeof(lgl));
for (int j = 0; j < n * m; j++) {
q.push(j);
lgl[j] = 1;
for (int k = i & (i - 1); k; k = i & (k - 1)) {
int val = dp[k][j] + dp[i ^ k][j] - fl[j];
if (val < dp[i][j]) {
dp[i][j] = val;
go[i][j] = make_pair(k, j);
}
}
}
while (((int)(q).size())) {
int j = q.front() / m, k = q.front() % m;
lgl[q.front()] = 0;
q.pop();
for (int l = 0; l < 4; l++) {
int x = j + dx[l], y = k + dy[l];
if (x < 0 || x >= n || y < 0 || y >= m) {
continue;
}
int num = dp[i][code(j, k)] + fl[code(x, y)];
if (num < dp[i][code(x, y)]) {
dp[i][code(x, y)] = num;
go[i][code(x, y)] = make_pair(i, code(j, k));
if (!lgl[code(x, y)]) {
q.push(code(x, y));
lgl[code(x, y)] = 1;
}
}
}
}
}
memset(ans, '.', sizeof(ans));
int minx = ((int)0x3f3f3f3f), mnpos;
for (int i = 0; i < n * m; i++) {
if (dp[(1 << (k)) - 1][i] < minx) {
minx = dp[(1 << (k)) - 1][i];
mnpos = i;
}
}
fio << minx << '\n';
dfs((1 << (k)) - 1, mnpos);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
fio << ans[code(i, j)];
}
fio << '\n';
}
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); (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>
using namespace std;
const double eps = 1e-8;
const long long MOD = 1000000007;
const long long INF = 0x3f3f3f3f;
int val[111][111];
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};
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++) {
scanf("%d", &val[i][j]);
}
}
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;
}
}
}
for (i = 0; i < k; i++) {
scanf("%d%d", &u, &v);
dp[(u - 1) * m + v][1 << i] = val[u][v];
}
for (j = 1; j <= n * m; j++) {
int flag = false;
for (u = 1; u <= n; u++) {
for (v = 1; v <= m; v++) {
p = (u - 1) * m + v;
for (i = 0; i < 4; i++) {
x = u + dx[i];
y = v + dy[i];
if (x < 1 || x > n || y < 1 || y > m) continue;
q = (x - 1) * m + y;
for (l = 0; l < (1 << k); l++) {
if (dp[q][l] > dp[p][l] + val[x][y]) {
dp[q][l] = dp[p][l] + val[x][y];
pre[q][l] = make_pair(p, l);
}
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);
flag = true;
}
}
}
}
}
}
if (!flag) break;
}
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 N = 2e2 + 5, M = 1 << 7, inf = 1e9;
struct second {
int mn = inf;
bitset<N> B;
} dp[N][M];
int n, m, k, a, b, tmp, tot, A[N], MSK;
int gt(int x, int y) { return (x * m + y); }
vector<int> adj[N];
int main() {
scanf("%d %d %d", &n, &m, &k);
MSK = 1 << k, tot = n * m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
tmp = gt(i, j);
scanf("%d", &A[tmp]);
if (i) adj[tmp].push_back(gt(i - 1, j));
if (j) adj[tmp].push_back(gt(i, j - 1));
if (i != n - 1) adj[tmp].push_back(gt(i + 1, j));
if (j != m - 1) adj[tmp].push_back(gt(i, j + 1));
}
for (int i = 0; i < k; i++) {
scanf("%d %d", &a, &b);
tmp = gt(--a, --b);
dp[tmp][1 << i].mn = A[tmp];
dp[tmp][1 << i].B[tmp] = 1;
}
for (int msk = 1; msk < MSK; msk++) {
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
for (int i = 0; i < tot; i++) {
for (int smsk = msk; smsk; smsk = (smsk - 1) & msk) {
if (msk == smsk) continue;
tmp = dp[i][smsk].mn + dp[i][msk ^ smsk].mn - A[i];
if (tmp >= dp[i][msk].mn) continue;
dp[i][msk].mn = tmp;
dp[i][msk].B = dp[i][smsk].B | dp[i][msk ^ smsk].B;
}
pq.push({dp[i][msk].mn, i});
}
while (pq.size()) {
pair<int, int> p = pq.top();
pq.pop();
if (p.first != dp[p.second][msk].mn) continue;
for (int x : adj[p.second])
if (p.first + A[x] < dp[x][msk].mn) {
dp[x][msk].mn = p.first + A[x];
dp[x][msk].B = dp[p.second][msk].B;
dp[x][msk].B[x] = 1;
pq.push({dp[x][msk].mn, x});
}
}
}
tmp = gt(a, b);
printf("%d\n", dp[tmp][MSK - 1].mn);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (dp[tmp][MSK - 1].B[gt(i, j)])
printf("X");
else
printf(".");
}
puts("");
}
}
|
#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);
}
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;
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]) {
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;
const int N = 220;
const int INF = 0x3f3f3f3f;
int dp[N][1 << 7];
int n, m, K;
int cnt;
int g[N][N];
int pg[N][N];
int aa[N * N];
int mp[N][N];
void floyd() {
for (int k = 0; k < cnt; k++) {
for (int i = 0; i < cnt; i++)
if (g[i][k] < INF) {
for (int j = 0; j < cnt; j++)
if (g[k][j] < INF) {
int u = g[i][k], v = g[k][j];
if (g[i][j] > u + v - aa[k]) {
g[i][j] = u + v - aa[k];
pg[i][j] = k;
}
}
}
}
}
int s[N * N];
int vis[N][N];
vector<int> pre[N * (1 << 7)];
void stn() {
memset(s, 0, sizeof(s));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
if (vis[i][j] != -1) {
s[mp[i][j]] = 1 << vis[i][j];
}
}
memset(dp, 0x3f, sizeof(dp));
int ed = 1 << K;
for (int i = 0; i < cnt; i++) {
for (int j = 0; j < ed; j++) {
pre[i * ed + j].clear();
}
}
for (int i = 0; i < cnt; i++) {
dp[i][s[i]] = aa[i];
}
for (int i = 1; i < ed; i++) {
for (int j = 0; j < cnt; j++) {
for (int k = (i - 1) & i; k; k = (k - 1) & i) {
int x = dp[j][k | s[j]], y = dp[j][i ^ k | s[j]];
if (dp[j][i] > x + y - aa[j]) {
dp[j][i] = x + y - aa[j];
int u = j * ed + i;
pre[u].clear();
pre[u].push_back(j);
pre[u].push_back(k | s[j]);
pre[u].push_back(j);
pre[u].push_back(i ^ k | s[j]);
}
}
}
for (int j = 0; j < cnt; j++) {
for (int j1 = 0; j1 < cnt; j1++) {
if (dp[j1][i | s[j1]] > dp[j][i] + g[j][j1] - aa[j]) {
dp[j1][i | s[j1]] = dp[j][i] + g[j][j1] - aa[j];
int u = j1 * ed + (i | s[j1]);
pre[u].clear();
pre[u].push_back(j);
pre[u].push_back(i);
}
}
}
}
}
int dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
int check(int i, int j) {
if (i < 1 || i > n || j < 1 || j > m) return 0;
return 1;
}
void prin(int u, int v) {
vis[u / m + 1][u % m + 1] = 1;
vis[v / m + 1][v % m + 1] = 1;
if (pg[u][v] == -1) return;
prin(u, pg[u][v]);
prin(pg[u][v], v);
}
void dfs(int u, int sta) {
int ed = 1 << K;
int x = u * ed + sta;
vis[u / m + 1][u % m + 1] = 1;
int num = pre[x].size();
if (num == 0) return;
if (num == 2) {
int u1 = pre[x][0], sta1 = pre[x][1];
prin(u1, u);
}
for (int i = 0; i < pre[x].size(); i += 2) {
dfs(pre[x][i], pre[x][i + 1]);
}
}
int main() {
while (scanf("%d%d%d", &n, &m, &K) != EOF) {
cnt = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &aa[cnt]);
mp[i][j] = cnt++;
}
}
memset(g, 0x3f, sizeof(g));
memset(pg, -1, sizeof(pg));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int k = 0; k < 4; k++) {
int ii = i + dir[k][0], jj = j + dir[k][1];
if (!check(ii, jj)) continue;
int u = mp[i][j], v = mp[ii][jj];
g[u][v] = aa[u] + aa[v];
}
}
}
for (int i = 0; i < cnt; i++) {
g[i][i] = aa[i];
}
memset(vis, -1, sizeof(vis));
for (int i = 0; i < K; i++) {
int x, y;
scanf("%d%d", &x, &y);
vis[x][y] = i;
}
floyd();
stn();
int ed = 1 << K;
int ans = INF, id;
for (int i = 0; i < cnt; i++) {
if (dp[i][ed - 1] < ans) {
ans = dp[i][ed - 1], id = i;
}
}
printf("%d\n", ans);
memset(vis, 0, sizeof(vis));
dfs(id, ed - 1);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
printf("%c", vis[i][j] ? 'X' : '.');
}
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int r, c, dist;
node() {}
node(int _r, int _c, int _dist) : r(_r), c(_c), dist(_dist) {}
bool operator<(node X) const { return dist > X.dist; }
};
int n, m, r[7], c[7], M[100][100], id[100][100];
int dist[200][200], px[200][200], py[200][200];
int memo[100][100][(1 << 7)], choosex[100][100][(1 << 7)],
choosey[100][100][(1 << 7)], choosem[100][100][(1 << 7)];
int solve(int x, int y, int mask) {
if (mask == 0) return 0;
int &ret = memo[x][y][mask];
if (ret == -1) {
if (__builtin_popcount(mask) == 1) {
int v = __builtin_ctz(mask);
ret = dist[x * m + y][r[v] * m + c[v]];
} else {
ret = 200000;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
for (int mask2 = (mask - 1) & mask; mask2 > 0;
mask2 = (mask2 - 1) & mask) {
int m1 = mask, m2 = mask2;
if (id[i][j] != -1) {
m1 &= ~(1 << id[i][j]);
m2 &= ~(1 << id[i][j]);
}
int aux = dist[x * m + y][i * m + j] + solve(i, j, m2) +
solve(i, j, m1 ^ m2);
if (aux < ret) {
ret = aux;
choosex[x][y][mask] = i;
choosey[x][y][mask] = j;
choosem[x][y][mask] = mask2;
}
}
}
}
return ret;
}
char sol[100][101];
void search(int x, int y, int mask) {
sol[x][y] = 'X';
if (mask == 0) return;
int x2, y2;
if (__builtin_popcount(mask) == 1) {
int v = __builtin_ctz(mask);
x2 = r[v];
y2 = c[v];
} else {
x2 = choosex[x][y][mask];
y2 = choosey[x][y][mask];
int mask2 = choosem[x][y][mask];
if (id[x2][y2] != -1) {
mask &= ~(1 << id[x2][y2]);
mask2 &= ~(1 << id[x2][y2]);
}
search(x2, y2, mask2);
search(x2, y2, mask ^ mask2);
}
while (x2 != x || y2 != y) {
sol[x2][y2] = 'X';
int x3 = px[x * m + y][x2 * m + y2], y3 = py[x * m + y][x2 * m + y2];
x2 = x3;
y2 = y3;
}
}
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", &M[i][j]);
int dr[] = {-1, 1, 0, 0}, dc[] = {0, 0, -1, 1};
int N = n * m;
for (int i = 0; i < N; ++i)
for (int j = 0; j < N; ++j) dist[i][j] = 200001;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
priority_queue<node> Q;
Q.push(node(i, j, 0));
dist[i * m + j][i * m + j] = 0;
while (!Q.empty()) {
node aux = Q.top();
Q.pop();
if (aux.dist > dist[i * m + j][aux.r * m + aux.c]) continue;
for (int d = 0; d < 4; ++d) {
int r2 = aux.r + dr[d];
int c2 = aux.c + dc[d];
if (r2 >= 0 && r2 < n && c2 >= 0 && c2 < m &&
aux.dist + M[r2][c2] < dist[i * m + j][r2 * m + c2]) {
Q.push(node(r2, c2, aux.dist + M[r2][c2]));
dist[i * m + j][r2 * m + c2] = aux.dist + M[r2][c2];
px[i * m + j][r2 * m + c2] = aux.r;
py[i * m + j][r2 * m + c2] = aux.c;
}
}
}
}
}
memset(id, -1, sizeof id);
for (int i = 0; i < k; ++i) {
scanf("%d %d", &r[i], &c[i]);
--r[i];
--c[i];
id[r[i]][c[i]] = i;
}
memset(memo, -1, sizeof memo);
printf("%d\n", M[r[0]][c[0]] + solve(r[0], c[0], (1 << k) - 2));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) sol[i][j] = '.';
search(r[0], c[0], (1 << k) - 2);
for (int i = 0; i < n; ++i) puts(sol[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e2 + 3, M = 1 << 7, inf = 1e9;
struct second {
int mn = inf;
bitset<N> B;
} dp[N][M];
int n, m, k, a, b, tmp, tot, A[N], MSK, cnt;
int gt(int x, int y) { return (x * m + y); }
vector<int> adj[N];
int main() {
scanf("%d %d %d", &n, &m, &k);
MSK = 1 << k, tot = n * m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
tmp = cnt++;
scanf("%d", &A[tmp]);
if (i) adj[tmp].push_back(gt(i - 1, j));
if (j) adj[tmp].push_back(gt(i, j - 1));
if (i != n - 1) adj[tmp].push_back(gt(i + 1, j));
if (j != m - 1) adj[tmp].push_back(gt(i, j + 1));
}
for (int i = 0; i < k; i++) {
scanf("%d %d", &a, &b);
tmp = gt(--a, --b);
dp[tmp][1 << i].mn = A[tmp];
dp[tmp][1 << i].B[tmp] = 1;
}
for (int msk = 1; msk < MSK; msk++) {
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
for (int i = 0; i < tot; i++) {
for (int smsk = msk; smsk; smsk = (smsk - 1) & msk) {
if (msk == smsk) continue;
tmp = dp[i][smsk].mn + dp[i][msk ^ smsk].mn - A[i];
if (tmp >= dp[i][msk].mn) continue;
dp[i][msk].mn = tmp;
dp[i][msk].B = dp[i][smsk].B | dp[i][msk ^ smsk].B;
}
pq.push({dp[i][msk].mn, i});
}
while (pq.size()) {
pair<int, int> p = pq.top();
pq.pop();
if (p.first != dp[p.second][msk].mn) continue;
for (int x : adj[p.second])
if (p.first + A[x] < dp[x][msk].mn) {
dp[x][msk].mn = p.first + A[x];
dp[x][msk].B = dp[p.second][msk].B;
dp[x][msk].B[x] = 1;
pq.push({dp[x][msk].mn, x});
}
}
}
tmp = gt(a, b);
printf("%d\n", dp[tmp][MSK - 1].mn);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (dp[tmp][MSK - 1].B[gt(i, j)])
printf("X");
else
printf(".");
}
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 105;
const int Maxk = 7;
const int Maxv = 205;
const int Inf = 1000000000;
int n, m, k;
int cost[Maxn][Maxn];
int dist[Maxv][Maxv], p[Maxv][Maxv];
int best[1 << Maxk][Maxv], pa[1 << Maxk][Maxv], pb[1 << Maxk][Maxv];
bool g[Maxn][Maxn];
bool Adj(int a, int b) { return abs(a / m - b / m) + abs(a % m - b % m) == 1; }
void printPath(int i, int j) {
g[i / m][i % m] = g[j / m][j % m] = true;
if (p[i][j] == -1) return;
printPath(i, p[i][j]);
printPath(p[i][j], j);
}
void Print(int i, int j) {
g[j / m][j % m] = true;
if (pa[i][j] == -1) return;
if (pa[i][j] != i) {
Print(pa[i][j], j);
Print(i ^ pa[i][j], j);
} else {
printPath(j, pb[i][j]);
Print(i, pb[i][j]);
}
}
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", &cost[i][j]);
fill((int*)best, (int*)best + (1 << Maxk) * Maxv, Inf);
for (int i = 0; i < k; i++) {
int x, y;
scanf("%d %d", &x, &y);
best[1 << i][m * (x - 1) + y - 1] = cost[x - 1][y - 1];
pa[1 << i][m * (x - 1) + y - 1] = -1;
}
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++)
if (i == j) {
dist[i][j] = cost[i / m][i % m];
p[i][j] = -1;
} else if (Adj(i, j)) {
dist[i][j] = cost[i / m][i % m] + cost[j / m][j % m];
p[i][j] = -1;
} else
dist[i][j] = Inf;
for (int k = 0; k < n * m; k++)
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++) {
int cand = dist[i][k] + dist[k][j] - cost[k / m][k % m];
if (cand < dist[i][j]) {
dist[i][j] = cand;
p[i][j] = k;
}
}
for (int i = 1; i < 1 << k; i++) {
for (int j = 0; j < n * m; j++)
for (int l = 1; l < i; l++)
if ((i | l) == i) {
int cand = best[l][j] + best[i ^ l][j] - cost[j / m][j % m];
if (cand < best[i][j]) {
best[i][j] = cand;
pa[i][j] = l;
}
}
for (int j = 0; j < n * m; j++)
for (int l = 0; l < n * m; l++) {
int cand = best[i][l] + dist[l][j] - cost[l / m][l % m];
if (cand < best[i][j]) {
best[i][j] = cand;
pa[i][j] = i;
pb[i][j] = l;
}
}
}
int i = (1 << k) - 1, j = 0;
for (int l = 0; l < n * m; l++)
if (best[i][l] < best[i][j]) {
j = l;
}
printf("%d\n", best[i][j]);
Print(i, j);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%c", g[i][j] ? 'X' : '.');
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
int f[101][101][1101], n, m, k, pre[101][101][1101][3], map[101][101], cnt,
queue[2000001][2], h, t, rx, ry;
bool ans[101][101], vis[101][101], vv[101][101];
void push(int i, int j) {
if (vis[i][j]) return;
queue[++t][0] = i;
queue[t][1] = j;
vis[i][j] = 1;
}
void update(int i, int j, int ni, int nj, int now) {
if (!i || !j || i > n || j > m) return;
vis[ni][nj] = 0;
if (f[i][j][now] > f[ni][nj][now] + map[i][j]) {
f[i][j][now] = f[ni][nj][now] + map[i][j];
pre[i][j][now][0] = ni;
pre[i][j][now][1] = nj;
pre[i][j][now][2] = now;
push(i, j);
}
}
void spfa(int now) {
while (h < t) {
h++;
int i = queue[h][0], j = queue[h][1];
update(i - 1, j, i, j, now);
update(i + 1, j, i, j, now);
update(i, j - 1, i, j, now);
update(i, j + 1, i, j, now);
}
h = t = 0;
}
void dfs(int i, int j, int stat) {
if (!i) return;
ans[i][j] = 1;
dfs(pre[i][j][stat][0], pre[i][j][stat][1], pre[i][j][stat][2]);
if (pre[i][j][stat][0] == i && pre[i][j][stat][1] == j)
dfs(pre[i][j][stat][0], pre[i][j][stat][1], stat ^ pre[i][j][stat][2]);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
memset(f, 0x7f7f7f7f, sizeof f);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
scanf("%d", &map[i][j]);
}
for (int i = 1, t1, t2; i <= k; i++) {
scanf("%d%d", &t1, &t2);
f[t1][t2][1 << (i - 1)] = map[t1][t2];
rx = t1, ry = t2;
vv[t1][t2] = 1;
}
for (int now = 1; now < (1 << k); now++) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
for (int sub = now & (now - 1); sub; sub = now & (sub - 1))
if (f[i][j][now] > f[i][j][sub] + f[i][j][now ^ sub] - map[i][j]) {
f[i][j][now] = f[i][j][sub] + f[i][j][now ^ sub] - map[i][j];
pre[i][j][now][0] = i;
pre[i][j][now][1] = j;
pre[i][j][now][2] = sub;
}
if (f[i][j][now] != 0x7f7f7f7f) push(i, j);
}
spfa(now);
}
dfs(rx, ry, (1 << k) - 1);
printf("%d\n", f[rx][ry][(1 << k) - 1]);
for (int i = 1; i <= n; i++, putchar('\n'))
for (int j = 1; j <= m; j++)
if (vv[i][j])
putchar('X');
else if (ans[i][j])
putchar('X');
else
putchar('.');
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T** grid_alloc(int y, int x) {
T** rv = new T*[y];
for (int i = 0; i < y; i++) rv[i] = new T[x];
return rv;
}
template <class T>
void grid_free(T** ptr, int y, int x) {
for (int i = 0; i < y; i++) delete[] ptr[i];
delete[] ptr;
}
void grid_print(int** ptr, int y, int x) {
for (int i = 0; i < y; i++) {
for (int j = 0; j < x; j++) printf("%d ", ptr[i][j]);
printf("\n");
}
}
int N, M, K;
int** flowers;
bool** pavement;
int points[10][2];
void shortest_path(int** sp_cost, int** sp_parent, int cy, int cx) {
for (int y = 0; y < N; y++)
for (int x = 0; x < M; x++) {
sp_cost[y][x] = 2000000000;
sp_parent[y][x] = -1;
}
int c = cy * M + cx, p = 0, cost = 0, ctotal = 0;
priority_queue<pair<int, pair<int, int> >,
vector<pair<int, pair<int, int> > >,
greater<pair<int, pair<int, int> > > >
q;
q.push(make_pair(0, make_pair(c, c)));
int offset_y[4] = {-1, 0, 1, 0};
int offset_x[4] = {0, 1, 0, -1};
while (!q.empty() && ctotal < N * M) {
cost = q.top().first;
c = q.top().second.first;
p = q.top().second.second;
q.pop();
cy = c / M;
cx = c % M;
if (sp_cost[cy][cx] != 2000000000) continue;
sp_cost[cy][cx] = cost;
sp_parent[cy][cx] = p;
ctotal++;
for (int i = 0; i < 4; i++) {
int ny = cy + offset_y[i];
int nx = cx + offset_x[i];
if (ny >= 0 && ny < N && nx >= 0 && nx < M &&
sp_cost[ny][nx] == 2000000000) {
int ncost = cost + flowers[ny][nx];
if (ncost < sp_cost[ny][nx])
q.push(make_pair(ncost, make_pair(ny * M + nx, c)));
}
}
}
}
int*** path_cost;
int*** path_parent;
int bitcount(int a) {
int r = 0;
while (a > 0) {
if (a & 0x1) r++;
a >>= 1;
}
return r;
}
int mask_normalize(int mask, int value) {
int i = 0;
int r = 0;
while (mask > 0) {
if (mask & 0x1) {
r |= (value & 0x1) << i;
value >>= 1;
}
mask >>= 1;
i++;
}
return r;
}
int mem[130][250];
int rtrace_c;
int rtrace_m1;
int rtrace_m2;
int solve(int mask, int c, bool backtrace) {
if (!backtrace && mem[mask][c] >= 0) return mem[mask][c];
int y = c / M;
int x = c % M;
int rtc_c = -1;
int rtc_m1 = 0;
int rtc_m2 = 0;
int** sp_cost = path_cost[c];
int** sp_parent = path_parent[c];
int rv = 2000000000;
int bc = bitcount(mask);
int ty = 0, tx = 0;
if (bc == 1) {
int point_i = 0, maskc = mask;
while (true) {
if (maskc & 0x1) break;
maskc >>= 1;
point_i++;
}
ty = points[point_i][0];
tx = points[point_i][1];
rv = sp_cost[ty][tx];
} else {
int mask_max = 0x1 << (bc - 1);
for (int sub = 1; sub < mask_max; sub++) {
int mask1 = mask_normalize(mask, sub);
int mask2 = mask_normalize(mask, ~sub);
for (int ny = 0; ny < N; ny++)
for (int nx = 0; nx < M; nx++) {
int cr = sp_cost[ny][nx];
int cc = ny * M + nx;
cr += solve(mask1, cc, false);
cr += solve(mask2, cc, false);
if (cr < rv) {
rv = cr;
ty = ny;
tx = nx;
rtc_c = cc;
rtc_m1 = mask1;
rtc_m2 = mask2;
}
}
}
}
if (backtrace) {
int tc = ty * M + tx;
while (sp_parent[ty][tx] != tc) {
pavement[ty][tx] = true;
tc = sp_parent[ty][tx];
ty = tc / M;
tx = tc % M;
}
}
rtrace_c = rtc_c;
rtrace_m1 = rtc_m1;
rtrace_m2 = rtc_m2;
return mem[mask][c] = rv;
}
void trace(int mask, int c) {
solve(mask, c, true);
int rtc_c = rtrace_c;
int rtc_m1 = rtrace_m1;
int rtc_m2 = rtrace_m2;
if (rtc_c >= 0) {
trace(rtc_m1, rtc_c);
trace(rtc_m2, rtc_c);
}
}
int main() {
for (int i = 0; i < 130; i++)
for (int j = 0; j < 250; j++) mem[i][j] = -1;
scanf("%d %d %d", &N, &M, &K);
flowers = grid_alloc<int>(N, M);
pavement = grid_alloc<bool>(N, M);
for (int y = 0; y < N; y++)
for (int x = 0; x < M; x++) {
scanf("%d", &flowers[y][x]);
pavement[y][x] = false;
}
for (int i = 0; i < K; i++) {
scanf("%d %d", &points[i][0], &points[i][1]);
points[i][0]--;
points[i][1]--;
}
path_cost = new int**[N * M];
path_parent = new int**[N * M];
for (int y = 0; y < N; y++)
for (int x = 0; x < M; x++) {
int c = y * M + x;
path_cost[c] = grid_alloc<int>(N, M);
path_parent[c] = grid_alloc<int>(N, M);
shortest_path(path_cost[c], path_parent[c], y, x);
}
int sy = points[0][0];
int sx = points[0][1];
solve((0x1 << K) - 1, sy * M + sx, false);
pavement[sy][sx] = true;
trace((0x1 << K) - 1, sy * M + sx);
int rv = 0;
for (int y = 0; y < N; y++)
for (int x = 0; x < M; x++)
if (pavement[y][x]) rv += flowers[y][x];
printf("%d\n", rv);
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) printf("%c", pavement[i][j] ? 'X' : '.');
printf("\n");
}
for (int c = 0; c < N * M; c++) {
grid_free<int>(path_cost[c], N, M);
grid_free<int>(path_parent[c], N, M);
}
delete[] path_cost;
delete[] path_parent;
grid_free<int>(flowers, N, M);
grid_free<bool>(pavement, N, M);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, tot;
struct Node {
int x, y, s, c;
Node(int X, int Y, int S, int C) {
x = X;
y = Y;
s = S;
c = C;
}
Node() {}
friend bool operator<(const Node& A, const Node& B) { return A.c > B.c; };
};
const int mm = 107;
const int go[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
int mp[mm][mm], mk[mm][mm];
int f[130][mm][mm], v[130][mm][mm];
pair<int, int> q[10];
int X, Y;
void solve() {
tot = 10000013 * 10;
memset(f, 127, sizeof(f));
memset(v, 0, sizeof(v));
priority_queue<Node> h;
while (!h.empty()) h.pop();
int b = 1 << k;
for (int i = 0; i < k; ++i) {
f[1 << i][q[i].first][q[i].second] = 0;
h.push(Node(q[i].first, q[i].second, 1 << i, 0));
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) h.push(Node(i, j, 0, 0)), f[0][i][j] = 0;
}
while (!h.empty()) {
Node t = h.top();
h.pop();
if (v[t.s][t.x][t.y]) continue;
v[t.s][t.x][t.y] = 1;
if (t.s == b - 1 && t.c + mp[t.x][t.y] < tot) {
tot = t.c + mp[t.x][t.y];
X = t.x, Y = t.y;
}
for (int i = 0; i < 4; ++i) {
int tx = t.x + go[i][0], ty = t.y + go[i][1];
if (tx < 1 || tx > n || ty < 1 || ty > m) continue;
if (t.c + mp[t.x][t.y] < f[t.s][tx][ty]) {
f[t.s][tx][ty] = t.c + mp[t.x][t.y];
h.push(Node(tx, ty, t.s, f[t.s][tx][ty]));
}
}
for (int p = (b - 1) ^ t.s, ps = p; ps; ps = (ps - 1) & p) {
if (v[ps][t.x][t.y]) {
int ss = t.s | ps;
int val = t.c + f[ps][t.x][t.y];
if (val < f[ss][t.x][t.y]) {
f[ss][t.x][t.y] = val;
h.push(Node(t.x, t.y, ss, val));
}
}
}
}
}
void recover(int x, int y, int b) {
mk[x][y] = 1;
for (int s = 1; s < b; ++s) {
if ((b | s) != b) continue;
if (f[s][x][y] + f[b - s][x][y] == f[b][x][y]) {
recover(x, y, s);
recover(x, y, b - s);
return;
}
}
for (int i = 0; i < 4; ++i) {
int tx = x + go[i][0], ty = y + go[i][1];
if (tx < 1 || tx > n || ty < 1 || ty > m) continue;
if (f[b][tx][ty] + mp[tx][ty] == f[b][x][y]) {
recover(tx, ty, b);
return;
}
}
}
int main() {
int T = 1;
for (int ci = 1; ci <= T; ++ci) {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
int x;
scanf("%d", &x);
mp[i][j] = x;
}
}
for (int i = 0; i < k; ++i) {
int x, y;
scanf("%d%d", &x, &y);
q[i] = pair<int, int>(x, y);
}
solve();
cout << tot << endl;
memset(mk, 0, sizeof(mk));
recover(X, Y, (1 << k) - 1);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
printf("%c", mk[i][j] ? 'X' : '.');
}
puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[205][205];
int b[205];
int edge[205][205];
long long dis[205][205];
long long dp[131][205];
vector<pair<int, int> > la[131][205];
int imp[13];
int dila[205][205];
bool had[205];
void solve(int x1, int x2) {
queue<pair<int, int> > q;
q.push(make_pair(x1, x2));
had[x1] = 1;
had[x2] = 1;
while (!q.empty()) {
int a1 = q.front().first, b1 = q.front().second;
q.pop();
had[dila[a1][b1]] = 1;
if (~dila[a1][b1]) {
q.push(make_pair(a1, dila[a1][b1]));
q.push(make_pair(dila[a1][b1], b1));
}
}
}
int main() {
int n, m, K;
cin >> n >> m >> K;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
b[i * m + j] = a[i][j];
if (i - 1 >= 0)
edge[(i - 1) * m + j][i * m + j] = edge[i * m + j][(i - 1) * m + j] = 1;
if (i + 1 < n)
edge[(i + 1) * m + j][i * m + j] = edge[i * m + j][(i + 1) * m + j] = 1;
if (j - 1 >= 0)
edge[i * m + j - 1][i * m + j] = edge[i * m + j][i * m + j - 1] = 1;
if (j + 1 < m)
edge[i * m + j + 1][i * m + j] = edge[i * m + j][i * m + j + 1] = 1;
}
}
int al = n * m;
memset(dila, -1, sizeof dila);
for (int i = 0; i < al; i++) {
for (int j = 0; j < al; j++) {
if (edge[i][j])
dis[i][j] = b[i] + b[j];
else
dis[i][j] = 1e9;
}
dis[i][i] = b[i];
}
for (int k = 0; k < al; k++) {
for (int i = 0; i < al; i++) {
for (int j = 0; j < al; j++) {
if (dis[i][j] > dis[i][k] + dis[k][j] - b[k]) {
dila[i][j] = k;
dis[i][j] = dis[i][k] + dis[k][j] - b[k];
}
}
}
}
for (int i = 0; i < K; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
imp[i] = x * m + y;
}
for (int j = 0; j < al; j++) {
for (int k = 0; k < 1 << K; k++) {
dp[k][j] = 1e9;
}
}
for (int i = 0; i < K; i++) {
dp[1 << i][imp[i]] = b[imp[i]];
had[imp[i]] = 1;
}
dp[0][0] = 0;
for (int i = 1; i < 1 << K; i++) {
priority_queue<pair<int, int> > q;
for (int j = 0; j < al; j++) {
for (int k = (i - 1) & i; k; k = (k - 1) & i) {
if (dp[i ^ k][j] + dp[k][j] - b[j] < dp[i][j]) {
dp[i][j] = dp[i ^ k][j] + dp[k][j] - b[j];
la[i][j].clear();
la[i][j].push_back(make_pair(i ^ k, j));
la[i][j].push_back(make_pair(k, j));
}
}
if (dp[i][j] < 1e8) {
q.push(make_pair(-dp[i][j], j));
}
}
while (!q.empty()) {
int x = -q.top().first, y = q.top().second;
q.pop();
for (int ii = 0; ii < al; ii++) {
if (!edge[ii][y]) continue;
if (x + b[ii] < dp[i][ii]) {
la[i][ii].clear();
la[i][ii].push_back(make_pair(i, y));
dp[i][ii] = x + b[ii];
q.push(make_pair(-dp[i][ii], ii));
}
}
}
}
long long mi = 1e9, id;
for (int i = 0; i < al; i++) {
if (mi > dp[(1 << K) - 1][i]) {
mi = dp[(1 << K) - 1][i];
id = i;
}
}
queue<pair<int, int> > q;
q.push(make_pair((1 << K) - 1, id));
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop();
had[y] = 1;
for (int i = 0; i < la[x][y].size(); i++) {
int x1 = la[x][y][i].first, y1 = la[x][y][i].second;
q.push(make_pair(x1, y1));
}
}
cout << mi << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (had[i * m + j])
cout << 'X';
else
cout << '.';
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MXN = (1LL << 8) + 10;
long long n, m, k, trn = 1, ans = 1e16, id = -1;
long long dp[MXN][MXN], A[MXN], mp[MXN][MXN];
vector<pair<long long, long long>> adj[MXN];
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
pq;
bitset<MXN> bs[MXN][MXN];
bool vis[MXN];
bool check(long long x, long long y) {
return (1 <= x && x <= n && 1 <= y && y <= m);
}
void Dij(long long mask) {
for (int u = 1; u < trn; u++) pq.push({dp[u][mask], u}), vis[u] = 0;
while (!pq.empty()) {
long long val = pq.top().first, u = pq.top().second;
pq.pop();
if (vis[u]) continue;
vis[u] = 1;
for (auto Pr : adj[u]) {
long long v = Pr.first, w = Pr.second;
if (dp[v][mask] > dp[u][mask] + w) {
dp[v][mask] = dp[u][mask] + w;
bs[v][mask] = bs[u][mask];
bs[v][mask][v] = 1;
pq.push({dp[v][mask], v});
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(dp, 63, sizeof dp);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> A[trn];
mp[i][j] = trn, trn++;
}
}
for (int i = 0; i < k; i++) {
long long x, y;
cin >> x >> y;
dp[mp[x][y]][1 << i] = A[mp[x][y]];
bs[mp[x][y]][1 << i][mp[x][y]] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (check(i - 1, j))
adj[mp[i][j]].emplace_back(mp[i - 1][j], A[mp[i - 1][j]]);
if (check(i + 1, j))
adj[mp[i][j]].emplace_back(mp[i + 1][j], A[mp[i + 1][j]]);
if (check(i, j - 1))
adj[mp[i][j]].emplace_back(mp[i][j - 1], A[mp[i][j - 1]]);
if (check(i, j + 1))
adj[mp[i][j]].emplace_back(mp[i][j + 1], A[mp[i][j + 1]]);
}
}
for (int mask = 1; mask < (1LL << k); mask++) {
for (int v = 1; v < trn; v++) {
for (int sub = mask;; sub = (sub - 1) & mask) {
dp[v][mask] = min(dp[v][mask], dp[v][sub] + dp[v][mask ^ sub] - A[v]);
if (dp[v][mask] == dp[v][sub] + dp[v][mask ^ sub] - A[v])
bs[v][mask] = bs[v][sub] | bs[v][mask ^ sub];
if (sub == 0) break;
}
}
Dij(mask);
}
for (int i = 1; i < trn; i++) {
if (dp[i][(1LL << k) - 1] < ans) {
ans = dp[i][(1LL << k) - 1], id = i;
}
}
cout << ans << '\n';
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cout << (bs[id][(1LL << k) - 1][mp[i][j]] ? 'X' : '.');
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int T, n, m, k;
int val[105][105];
int ps[105][105];
int sz;
struct z {
int a, b, c;
};
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
int tr(int a, int b, int sta) {
int ww = a * m;
ww += b;
ww *= sz;
ww += sta;
return ww;
}
z tt(int ww) {
int c = ww % sz;
ww /= sz;
int b = ww % m;
int a = ww / m;
return (z){a, b, c};
}
const int maxn = 205;
vector<pair<int, int> > v[maxn];
pair<int, int> pre[maxn][1005];
int dp[maxn][1005];
int dis[maxn];
queue<int> q;
bool inq[maxn];
const int INF = 1e9 + 7;
int st, en;
void sol(int x, int s) {
if (x < 0) return;
ps[x / m][x % m] = 0;
int a, b;
a = pre[x][s].first;
b = pre[x][s].second;
sol(a, b);
if (b != s && b >= 0) sol(a, b ^ s);
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < maxn; i++)
for (int j = 0; j < 1005; j++) pre[i][j] = {-1, -1};
memset(dp, 60, sizeof(dp));
sz = (1 << k);
memset(ps, 0xff, sizeof(ps));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &val[i][j]);
}
}
for (int i = 0; i < k; i++) {
int a, b;
scanf("%d%d", &a, &b);
ps[a - 1][b - 1] = i;
dp[(a - 1) * m + b - 1][1 << i] = val[a - 1][b - 1];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int z = 0; z < 4; z++) {
int x = dx[z] + i;
int y = dy[z] + j;
if (x < 0 || y < 0 || x >= n || y >= m) continue;
v[i * m + j].push_back(make_pair(x * m + y, val[x][y]));
}
}
}
for (int i = 1; i < sz; i++) {
for (int j = 0; j < n * m; j++) {
for (int g = (i - 1) & i; g; g = (g - 1) & i) {
int w = g ^ i;
int va = dp[j][w] + dp[j][g] - val[j / m][j % m];
if (va < dp[j][i]) {
pre[j][i] = {j, g};
dp[j][i] = va;
}
}
}
queue<int> q;
bool in[205];
for (int j = 0; j < n * m; j++) {
in[j] = 1;
q.push(j);
}
while (!q.empty()) {
int z = q.front();
q.pop();
in[z] = 0;
for (int j = 0; j < v[z].size(); j++) {
int to = v[z][j].first;
int va = v[z][j].second;
if (va + dp[z][i] < dp[to][i]) {
dp[to][i] = va + dp[z][i];
pre[to][i] = {z, i};
if (!in[to]) {
in[to] = 1;
q.push(to);
}
}
}
}
}
int res;
int ans = INF;
for (int i = 0; i < n * m; i++) {
if (dp[i][sz - 1] < ans) res = i;
ans = min(ans, dp[i][sz - 1]);
}
cout << ans << endl;
sol(res, sz - 1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (ps[i][j] >= 0)
printf("X");
else
printf(".");
}
if (i != n - 1) puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
template <class S>
inline void read(S& arg) {
cin >> arg;
}
template <class S>
inline void readA(S Lptr, S Rptr) {
while (Lptr != Rptr) {
read(*Lptr);
Lptr++;
}
}
template <class S, class... T>
inline void read(S& arg, T&... rest) {
read(arg);
read(rest...);
}
char delimiter = ' ';
template <class S>
inline void write(S arg) {
cout << arg << '\n';
}
template <class S, class... T>
inline void write(S arg, T... rest) {
cout << arg << delimiter;
write(rest...);
}
template <class S>
inline void writeA(S Lptr, S Rptr) {
while (Lptr != Rptr) {
cout << *Lptr;
Lptr++;
if (Lptr != Rptr) cout << delimiter;
}
cout << '\n';
}
template <class T, class S>
inline bool smin(T& a, S b) {
return (T)b < a ? a = b, 1 : 0;
}
template <class T, class S>
inline bool smax(T& a, S b) {
return a < (T)b ? a = b, 1 : 0;
}
constexpr int MOD = 1e9 + 9;
constexpr int N = 200 + 10;
template <typename T>
inline T mod(T& v) {
return v = (v % MOD + MOD) % MOD;
}
template <typename T>
inline long long dom(T v) {
return (v % MOD + MOD) % MOD;
}
template <typename S, typename T>
inline S add(S& l, T r) {
return mod(l += r);
}
long long po(long long v, long long u) {
return u ? po(v * v % MOD, u >> 1) * (u & 1 ? v : 1) % MOD : 1;
}
int n, m, k;
int a[N][N], pos[N];
int dist[N][N];
bitset<N> path[N][N];
int dp[1 << 7][N];
bitset<N> pd[1 << 7][N];
inline int Get(int x, int y) { return x * m + y; }
inline void Add(int i, int j, int x, int y, int d) {
i = Get(i, j);
x = Get(x, y);
dist[i][x] = d;
path[i][x][i] = true;
path[i][x][x] = true;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(dist, 63, sizeof(dist));
read(n, m, k);
for (int i = 0; i < (int)n; i++) {
for (int j = 0; j < (int)m; j++) {
read(a[i][j]);
Add(i, j, i, j, a[i][j]);
if (i) {
Add(i, j, i - 1, j, a[i - 1][j] + a[i][j]);
Add(i - 1, j, i, j, a[i][j] + a[i - 1][j]);
}
if (j) {
Add(i, j, i, j - 1, a[i][j - 1] + a[i][j]);
Add(i, j - 1, i, j, a[i][j] + a[i][j - 1]);
}
}
}
for (int i = 0; i < (int)k; i++) {
int x, y;
read(x, y);
x--, y--;
pos[i] = Get(x, y);
}
int M = n * m;
for (int k = 0; k < (int)M; k++)
for (int i = 0; i < (int)M; i++)
for (int j = 0; j < (int)M; j++)
if (smin(dist[i][j], dist[i][k] + dist[k][j] - a[k / m][k % m]))
path[i][j] = path[i][k] | path[k][j];
for (int i = 0; i < (int)M; i++) {
dp[0][i] = dist[i][i];
pd[0][i] = path[i][i];
}
for (int mask = 1; mask < (int)(1 << k); mask++) {
if (__builtin_popcount(mask) == 1) {
int id = __builtin_ctz(mask);
for (int i = 0; i < (int)M; i++) {
dp[mask][i] = dist[pos[id]][i];
pd[mask][i] = path[pos[id]][i];
}
continue;
}
for (int i = 0; i < (int)M; i++) {
dp[mask][i] = 1e9;
for (int sub = mask; sub; sub = (sub - 1) & mask)
if (smin(dp[mask][i], dp[mask ^ sub][i] + dp[sub][i] - dist[i][i]))
pd[mask][i] = pd[mask ^ sub][i] | pd[sub][i];
}
for (int i = 0; i < (int)M; i++)
for (int j = 0; j < (int)M; j++)
if (smin(dp[mask][i], dp[mask][j] + dist[j][i] - dist[j][j]))
pd[mask][i] = pd[mask][j] | path[j][i];
}
int id = 0;
for (int i = 0; i < (int)M; i++)
if (dp[(1 << k) - 1][id] > dp[(1 << k) - 1][i]) id = i;
cout << dp[(1 << k) - 1][id] << endl;
for (int i = 0; i < (int)n; i++) {
for (int j = 0; j < (int)m; j++) {
if (pd[(1 << k) - 1][id][Get(i, j)])
cout << 'X';
else
cout << '.';
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 203, maxmask = 131;
int n, m, r, c, t, root, u[10], d[maxn][maxn], df[maxn][maxn], used[maxn],
dp[maxn][maxmask], pf[maxn][maxmask], bf[maxn][maxmask];
void markAns(int x, int y) {
if (df[x][y] < 0) {
used[x] = used[y] = 1;
} else {
markAns(x, df[x][y]);
markAns(df[x][y], y);
}
}
void dfsAns(int x, int y) {
if ((y & -y) == y || pf[x][y] >= 0) {
if (pf[x][y] != -1) {
markAns(x, pf[x][y]);
dfsAns(pf[x][y], y);
} else {
int w = -1;
for (int i = 0; w < 0; ++i)
if ((1 << i) == y) w = i;
markAns(x, u[w]);
}
} else {
dfsAns(x, bf[x][y]);
dfsAns(x, y - bf[x][y]);
}
}
inline void readInt(int &v) {
char c = getchar();
while (!isdigit(c)) c = getchar();
for (v = 0; isdigit(c); c = getchar()) v = v * 10 + c - '0';
}
int main() {
memset(d, 0x3f, sizeof(d));
memset(df, 0xff, sizeof(df));
readInt(r);
readInt(c);
readInt(m);
n = r * c;
for (int i = 0; i < r; ++i)
for (int j = 0; j < c; ++j, ++t) readInt(d[t][t]);
for (int i = 0; i < r; ++i)
for (int j = 0, k; j < c; ++j) {
k = i * c + j;
if (j > 0) d[k][k - 1] = d[k][k] + d[k - 1][k - 1];
if (j + 1 < c) d[k][k + 1] = d[k][k] + d[k + 1][k + 1];
if (i > 0) d[k][k - c] = d[k][k] + d[k - c][k - c];
if (i + 1 < r) d[k][k + c] = d[k][k] + d[k + c][k + c];
}
for (int i = 0, x, y; i < m; ++i) {
readInt(x);
readInt(y);
u[i] = (x - 1) * c + (y - 1);
}
for (int k = 0; k < n; ++k)
for (int i = 0; i < n; ++i)
for (int j = 0, w; j < n; ++j) {
w = d[i][k] + d[k][j] - d[k][k];
if (w < d[i][j]) {
d[i][j] = w;
df[i][j] = k;
}
}
memset(pf, 0xff, sizeof(pf));
memset(bf, 0xff, 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, w; i < (1 << m); ++i) {
if ((i & -i) == i) continue;
for (int j = 0; j < n; ++j) {
dp[j][i] = 0x3fffffff;
for (int k = (i - 1) & i; k > 0; k = (k - 1) & i)
if ((i | k) == i) {
w = dp[j][k] + dp[j][i ^ k] - d[j][j];
if (w < dp[j][i]) {
dp[j][i] = w;
bf[j][i] = i ^ k;
}
}
}
for (int j = 0; j < n; ++j)
for (int k = 0; k < n; ++k) {
w = dp[k][i] + d[j][k] - d[k][k];
if (w < dp[j][i]) {
dp[j][i] = w;
pf[j][i] = k;
}
}
}
int ans = 0x7fffffff;
for (int i = 0; i < n; ++i)
if (dp[i][(1 << m) - 1] < ans) {
ans = dp[i][(1 << m) - 1];
root = i;
}
printf("%d\n", ans);
dfsAns(root, (1 << m) - 1);
for (int i = 0, k = 0; i < r; ++i) {
for (int j = 0; j < c; ++j, ++k) putchar(used[k] ? 'X' : '.');
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char b[128][128];
int a[128][128];
int d[1 << 10][128][128];
int f[1 << 10][128][128];
int n, m, islands;
int di[] = {-1, 1, 0, 0};
int dj[] = {0, 0, -1, 1};
int x[10];
int y[10];
void NextMask(int& mask, int& o, int& z) {
if (z + o == islands) {
z = 0;
++o;
mask = (1 << o) - 1;
return;
}
mask ^= 3 << (o + z - 1);
if (o == 1) {
++z;
o = 0;
while (mask & (1 << (z + o))) ++o;
} else {
--o;
mask ^= ((1 << o) - 1) << z;
mask ^= (1 << o) - 1;
z = 0;
}
}
void Minify(int d[128][128], int f[128][128], int mask) {
struct V {
int d;
int i;
int j;
V(int i, int j, int d) : i(i), j(j), d(d) {}
inline bool operator<(const V& v) const { return d > v.d; }
};
priority_queue<V> q;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (d[i][j] < 0x7f7f7f7f) q.push(V(i, j, d[i][j]));
while (q.size()) {
V cur = q.top();
q.pop();
if (d[cur.i][cur.j] < cur.d) continue;
for (int r = 0; r < 4; r++) {
int ni = cur.i + di[r];
int nj = cur.j + dj[r];
if (ni < 0 || ni >= n || nj < 0 || nj >= m) continue;
int nd = d[cur.i][cur.j] + a[ni][nj];
if (d[ni][nj] <= nd) continue;
d[ni][nj] = nd;
f[ni][nj] = ((cur.i * m + cur.j) << islands) | mask;
q.push(V(ni, nj, d[ni][nj]));
}
}
}
void Restore(int mn, int curi, int curj) {
for (int i = 0; i < n; i++) memset(b[i], '.', m);
int curmask = (1 << islands) - 1;
while (true) {
b[curi][curj] = 'X';
if (f[curmask][curi][curj] == -1) break;
int frommask = f[curmask][curi][curj] & ((1 << islands) - 1);
int fromj = (f[curmask][curi][curj] >> islands) % m;
int fromi = (f[curmask][curi][curj] >> islands) / m;
int x = frommask ^ curmask;
if (x) {
int xi = curi;
int xj = curj;
while (true) {
b[xi][xj] = 'X';
if (f[x][xi][xj] == -1) break;
int fj = (f[x][xi][xj] >> islands) % m;
int fi = (f[x][xi][xj] >> islands) / m;
xi = fi;
xj = fj;
}
}
curi = fromi;
curj = fromj;
curmask = frommask;
}
}
int main() {
memset(d, 0x3f, sizeof(d));
memset(f, -1, sizeof(f));
scanf("%d%d%d", &n, &m, &islands);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &a[i][j]);
int def = 0;
for (int i = 0; i < islands; i++) {
scanf("%d%d", &x[i], &y[i]);
--x[i], --y[i];
def += a[x[i]][y[i]];
a[x[i]][y[i]] = 0;
}
int k = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (a[i][j] == 0) {
d[(int)(1 << k)][i][j] = 0;
Minify(d[(int)(1 << k)], f[(int)(1 << k)], (int)(1 << k));
++k;
}
int mask = 3;
int o = 2;
int z = 0;
for (int i = islands + 1; i < (1 << islands); i++) {
for (int bit = 0; bit < islands; bit++) {
if ((mask & (1 << bit)) == 0) continue;
int fromMask = mask ^ (1 << bit);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int nd = d[fromMask][i][j] + d[(int)(1 << bit)][i][j] - a[i][j];
if (nd < d[mask][i][j]) {
d[mask][i][j] = nd;
f[mask][i][j] = ((i * m + j) << islands) | fromMask;
}
}
}
Minify(d[mask], f[mask], mask);
NextMask(mask, o, z);
}
int res = INT_MAX;
int resi = -1;
int resj = -1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (d[(1 << islands) - 1][i][j] < res) {
res = d[(1 << islands) - 1][i][j];
resi = i;
resj = j;
}
printf("%d\n", res + def);
Restore(res, resi, resj);
for (int i = 0; i < n; i++) puts(b[i]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 202, K = 7;
int n, m, k, u, v, x, y, t, a, b, ans = inf;
int A[MAXN], bad[K];
int dp[1 << K][MAXN];
bitset<MAXN> B[1 << K][MAXN];
vector<int> G[MAXN];
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>>
pq;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < n * m; i++) cin >> A[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (i) G[(i - 1) * m + j].push_back(i * m + j);
if (j) G[i * m + (j - 1)].push_back(i * m + j);
if (i < n - 1) G[(i + 1) * m + j].push_back(i * m + j);
if (j < m - 1) G[i * m + (j + 1)].push_back(i * m + j);
}
memset(dp, 63, sizeof(dp));
for (int i = 0; i < n * m; i++) dp[0][i] = A[i], B[0][i].set(i);
for (int i = 0; i < k; i++) {
cin >> x >> y;
x--;
y--;
x = x * m + y;
bad[i] = x;
dp[1 << i][x] = A[x];
B[1 << i][x].set(x);
}
for (int mask = 1; mask < (1 << k); mask++) {
for (int v = 0; v < n * m; v++)
for (int sub = mask; sub; sub = (sub - 1) & mask)
for (int u : G[v]) {
if (dp[sub][v] + dp[mask ^ sub][u] < dp[mask][v]) {
dp[mask][v] = dp[sub][v] + dp[mask ^ sub][u];
B[mask][v] = B[sub][v] | B[mask ^ sub][u];
}
}
for (int v = 0; v < n * m; v++) pq.push({dp[mask][v], v});
while (pq.size()) {
int v = pq.top().second;
pq.pop();
for (int u : G[v])
if (dp[mask][v] + A[u] < dp[mask][u]) {
dp[mask][u] = dp[mask][v] + A[u];
B[mask][u] = B[mask][v];
B[mask][u].set(u);
pq.push({dp[mask][u], u});
}
}
}
cout << dp[(1 << k) - 1][bad[0]] << '\n';
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (B[(1 << k) - 1][bad[0]][i * m + j])
cout << "X";
else
cout << ".";
}
cout << '\n';
}
return 0;
}
|
#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;
for (int i = 0; i < (1 << k); i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= m; k++) {
dp[j][k][i] = INF;
pre[j][k][i] = NODE(-1, -1, -1);
}
}
}
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++) {
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 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 (pst - st) 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;
int h[222], row, col, m;
int x[9], y[9];
int dp[1 << 7][222];
priority_queue<pair<int, int> > q;
bool upd(int& x, int y) {
if (x == -1 || x > y) {
x = y;
return true;
}
return false;
}
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, -1, 0, 1};
bool ff[111][111];
void output(int X, int Y, int mask) {
if ((mask & -mask) == mask) {
int len = 0;
while ((1 << len) != mask) len++;
if (x[len] == X && y[len] == Y) {
ff[X][Y] = true;
return;
}
} else {
int B = 0;
do {
if (dp[mask][X * col + Y] ==
dp[B][X * col + Y] + dp[mask - B][X * col + Y] - h[X * col + Y]) {
output(X, Y, B);
output(X, Y, mask - B);
return;
}
} while (B = (B - mask) & mask);
}
for (int i = 0; i < 4; i++) {
int x2 = X + dx[i], y2 = Y + dy[i];
if (x2 >= 0 && x2 < row && y2 >= 0 && y2 < col &&
dp[mask][X * col + Y] == dp[mask][x2 * col + y2] + h[X * col + Y]) {
ff[X][Y] = true;
output(x2, y2, mask);
return;
}
}
}
int main() {
for (int _ = 1; _--;) {
scanf("%d%d%d", &row, &col, &m);
for (int i = 0; i < row; i++)
for (int j = 0; j < col; j++) scanf("%d", &h[i * col + j]);
for (int i = 0; i < m; i++) {
scanf("%d%d", &x[i], &y[i]);
--x[i];
--y[i];
}
for (int mask = 1; mask < (1 << m); mask++) {
if ((mask & -mask) == mask) {
int len = 0;
while ((1 << len) != mask) len++;
for (int i = 0; i < row; i++)
for (int j = 0; j < col; j++) dp[mask][i * col + j] = -1;
dp[mask][x[len] * col + y[len]] = h[x[len] * col + y[len]];
q.push(make_pair(-(h[x[len] * col + y[len]]), x[len] * col + y[len]));
} else {
int B = 0;
memset(dp[mask], -1, sizeof(dp[mask]));
do {
if (B == 0 || B == mask) continue;
for (int i = 0; i < row; i++)
for (int j = 0; j < col; j++)
upd(dp[mask][i * col + j], dp[B][i * col + j] +
dp[mask - B][i * col + j] -
h[i * col + j]);
} while (B = (B - mask) & mask);
for (int i = 0; i < row; i++)
for (int j = 0; j < col; j++)
q.push(make_pair(-dp[mask][i * col + j], i * col + j));
}
while (!q.empty()) {
int dis = -q.top().first;
int x = q.top().second / col, y = q.top().second % col;
q.pop();
if (dis != dp[mask][x * col + y]) continue;
for (int i = 0; i < 4; i++) {
int x2 = x + dx[i], y2 = y + dy[i];
if (x2 >= 0 && x2 < row && y2 >= 0 && y2 < col &&
upd(dp[mask][x2 * col + y2],
dp[mask][x * col + y] + h[x2 * col + y2]))
q.push(make_pair(-dp[mask][x2 * col + y2], x2 * col + y2));
}
}
}
int out = -1, X, Y;
for (int i = 0; i < row; i++)
for (int j = 0; j < col; j++)
if (upd(out, dp[(1 << m) - 1][i * col + j])) X = i, Y = j;
printf("%d\n", out);
memset(ff, 0, sizeof(ff));
output(X, Y, (1 << m) - 1);
for (int i = 0; i < row; i++, puts(""))
for (int j = 0; j < col; j++) putchar(ff[i][j] ? 'X' : '.');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (1 << 29);
const int N = 105, M = 105, NM = 205, K = 8;
int n, m, k, a[N][M], x[NM], y[NM], dp[1 << K][NM], dist[NM][NM],
dist_parent[NM][NM];
pair<int, bool> dp_parent[1 << K][NM];
char result[N][M];
void construct_path(int i, int j) {
if (dist_parent[i][j] == -1) {
result[x[i]][y[i]] = 'X';
result[x[j]][y[j]] = 'X';
} else {
int p = dist_parent[i][j];
construct_path(i, p);
construct_path(p, j);
}
}
void construct_set(int i, int j) {
if (dp_parent[i][j].first == -1) {
for (int h = 0; h < k; h++)
if (i & (1 << h)) {
construct_path(h, j);
}
} else {
pair<int, bool> p = dp_parent[i][j];
if (p.second) {
construct_set(p.first, j);
construct_set(i & ~p.first, j);
} else {
construct_set(i, p.first);
construct_path(p.first, j);
}
}
}
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]--;
}
int c = k;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
bool flag = true;
for (int a = 0; a < k; a++)
if (i == x[a] && j == y[a]) flag = false;
if (flag) {
x[c] = i;
y[c] = j;
c++;
}
}
for (int i = 0; i < c; i++)
for (int j = 0; j < c; j++) {
if (i != j && ((abs(x[i] - x[j]) + abs(y[i] - y[j]) == 1))) {
dist[i][j] = a[x[j]][y[j]];
} else {
dist[i][j] = inf;
}
dist_parent[i][j] = -1;
}
for (int i = 0; i < c; i++) dist[i][i] = 0;
for (int i = 0; i < c; i++)
for (int j = 0; j < c; j++)
for (int k = 0; k < c; k++) {
int new_dist = dist[j][i] + dist[i][k];
if (new_dist < dist[j][k]) {
dist[j][k] = new_dist;
dist_parent[j][k] = i;
}
}
for (int i = 0; i < c; i++)
for (int j = 0; j < c; j++)
if (i != j) dist[i][j] -= a[x[j]][y[j]];
for (int i = 0; i < 1 << k; i++) {
if (i) {
for (int j = 0; j < c; j++) {
for (int h = 0; h < k; h++)
if (i & (1 << h)) dp[i][j] += a[x[h]][y[h]] + dist[h][j];
if (!(j < k && (i & (1 << j)))) dp[i][j] += a[x[j]][y[j]];
dp_parent[i][j].first = -1;
for (int g = i; g; g = (g - 1) & i)
if (g && (i & ~g)) {
int new_v = dp[g][j] + dp[i & ~g][j] - a[x[j]][y[j]];
if (new_v < dp[i][j]) {
dp[i][j] = new_v;
dp_parent[i][j] = make_pair(g, true);
}
}
}
for (int j = 0; j < c; j++) {
for (int k = 0; k < c; k++) {
int new_v = dp[i][j] + dist[j][k] + a[x[k]][y[k]];
if (new_v < dp[i][k]) {
dp[i][k] = new_v;
dp_parent[i][k] = make_pair(j, false);
}
}
}
} else {
for (int j = 0; j < c; j++) dp[i][j] = 0;
}
}
int best = 0;
for (int j = 0; j < c; j++)
if (dp[(1 << k) - 1][j] < dp[(1 << k) - 1][best]) best = j;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) result[i][j] = '.';
cout << dp[(1 << k) - 1][best] << endl;
construct_set((1 << k) - 1, best);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << result[i][j];
cout << endl;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.