[SWUST1759] 骑士共存问题(最大流,最大独立集)

题目链接:https://www.oj.swust.edu.cn/problem/show/1759

和方格取数一样建模就行了。

  1 #include <bits/stdc++.h>
  2 using namespace std;
  3
  4 typedef struct Edge {
  5     int u, v, w, next;
  6 }Edge;
  7
  8 const int inf = 0x7f7f7f7f;
  9 const int maxn = 44444;
 10
 11 int cnt, dhead[maxn];
 12 int cur[maxn], dd[maxn];
 13 Edge dedge[800001];
 14 int S, T, N;
 15
 16 void init() {
 17     memset(dhead, -1, sizeof(dhead));
 18     for(int i = 0; i < maxn; i++) dedge[i].next = -1;
 19     S = 0; cnt = 0;
 20 }
 21
 22 void adde(int u, int v, int w, int c1=0) {
 23     dedge[cnt].u = u; dedge[cnt].v = v; dedge[cnt].w = w;
 24     dedge[cnt].next = dhead[u]; dhead[u] = cnt++;
 25     dedge[cnt].u = v; dedge[cnt].v = u; dedge[cnt].w = c1;
 26     dedge[cnt].next = dhead[v]; dhead[v] = cnt++;
 27 }
 28
 29 bool bfs(int s, int t, int n) {
 30     queue<int> q;
 31     for(int i = 0; i < n; i++) dd[i] = inf;
 32     dd[s] = 0;
 33     q.push(s);
 34     while(!q.empty()) {
 35         int u = q.front(); q.pop();
 36         for(int i = dhead[u]; ~i; i = dedge[i].next) {
 37             if(dd[dedge[i].v] > dd[u] + 1 && dedge[i].w > 0) {
 38                 dd[dedge[i].v] = dd[u] + 1;
 39                 if(dedge[i].v == t) return 1;
 40                 q.push(dedge[i].v);
 41             }
 42         }
 43     }
 44     return 0;
 45 }
 46
 47 int dinic(int s, int t, int n) {
 48     int st[maxn], top;
 49     int u;
 50     int flow = 0;
 51     while(bfs(s, t, n)) {
 52         for(int i = 0; i < n; i++) cur[i] = dhead[i];
 53         u = s; top = 0;
 54         while(cur[s] != -1) {
 55             if(u == t) {
 56                 int tp = inf;
 57                 for(int i = top - 1; i >= 0; i--) {
 58                     tp = min(tp, dedge[st[i]].w);
 59                 }
 60                 flow += tp;
 61                 for(int i = top - 1; i >= 0; i--) {
 62                     dedge[st[i]].w -= tp;
 63                     dedge[st[i] ^ 1].w += tp;
 64                     if(dedge[st[i]].w == 0) top = i;
 65                 }
 66                 u = dedge[st[top]].u;
 67             }
 68             else if(cur[u] != -1 && dedge[cur[u]].w > 0 && dd[u] + 1 == dd[dedge[cur[u]].v]) {
 69                 st[top++] = cur[u];
 70                 u = dedge[cur[u]].v;
 71             }
 72             else {
 73                 while(u != s && cur[u] == -1) {
 74                     u = dedge[st[--top]].u;
 75                 }
 76                 cur[u] = dedge[cur[u]].next;
 77             }
 78         }
 79     }
 80     return flow;
 81 }
 82
 83 typedef pair<int, int> pii;
 84 const int dx[11] = {-1,1,2,2,1,-1,-2,-2};
 85 const int dy[11] = {-2,-2,-1,1,2,2,1,-1};
 86 const int maxm = 1010;
 87 int n, m;
 88 int G[maxm][maxm], icnt;
 89 map<pii, int> shawanyiera;
 90
 91 inline int id(int x, int y) {
 92     return shawanyiera[pii(x, y)];
 93 }
 94
 95 inline bool ok(int x, int y) {
 96         return x >= 1 && x <= n && y >= 1 && y <= n;
 97 }
 98
 99 int main() {
100     // freopen("in", "r", stdin);
101     int u, v;
102     scanf("%d%d",&n,&m);
103     memset(G, 0, sizeof(G));
104     init(); shawanyiera.clear(); icnt = 0;
105     for(int i = 0; i < m; i++) {
106         scanf("%d%d",&u,&v);
107         G[u][v] = 1;
108     }
109     for(int i = 1; i <= n; i++) {
110         for(int j = 1; j <= n; j++) {
111             if(G[i][j]) continue;
112             shawanyiera[pii(i, j)] = ++icnt;
113         }
114     }
115     S = 0, T = 2 * icnt + 1, N = T + 1;
116     for(int i = 1; i <= icnt; i++) {
117         adde(S, i, 1);
118         adde(i+icnt, T, 1);
119     }
120     for(int i = 1; i <= n; i++) {
121         for(int j = 1; j <= n; j++) {
122             if(G[i][j]) continue;
123             for(int k = 0; k < 8; k++) {
124                 int x = i + dx[k];
125                 int y = j + dy[k];
126                 if(!ok(x, y)) continue;
127                 if(G[x][y]) continue;
128                 adde(id(i,j), icnt+id(x,y), inf);
129             }
130         }
131     }
132     // cout << icnt << endl;
133     printf("%d\n", icnt-dinic(S, T, N)/2);
134
135     return 0;
136 }
时间: 2024-10-14 09:32:44

[SWUST1759] 骑士共存问题(最大流,最大独立集)的相关文章

[luoguP3355] 骑士共存问题(二分图最大独立集)

传送门 模型 二分图最大独立集,转化为二分图最大匹配,从而用最大流解决. 实现 首先把棋盘黑白染色,使相邻格子颜色不同. 把所有可用的黑色格子看做二分图X集合中顶点,可用的白色格子看做Y集合顶点. 建立附加源S汇T,从S向X集合中每个顶点连接一条容量为1的有向边,从Y集合中每个顶点向T连接一条容量为1的有向边. 从每个可用的黑色格子向骑士一步能攻击到的可用的白色格子连接一条容量为无穷大的有向边. 求出网络最大流,要求的结果就是可用格子的数量减去最大流量. 分析 用网络流的方法解决棋盘上的问题,一

【网络流24题】骑士共存问题(最大流)

[网络流24题]骑士共存问题(最大流) 题面 Cogs 题解 这题本质上和方格取数问题没有任何区别 首先也是可以黑白染色 因为马必定会跳到异色点上面去 然后同样的,源点向一种颜色,另一种颜色向汇点连边 因为代价就是1,所以容量都是1 这里考虑的"相邻"的情况是马的跳法 因此,枚举从当前点能够到达的位置,连一条容量为INF的边过去 障碍直接特殊考虑就行了 最后的答案就是所有可以放的位置数减去最大流(最小割) #include<iostream> #include<cst

P3355 骑士共存问题 网络流

骑士共存 题目描述 在一个 n*n个方格的国际象棋棋盘上,马(骑士)可以攻击的棋盘方格如图所示.棋盘上某些方格设置了障碍,骑士不得进入 对于给定的 n*n 个方格的国际象棋棋盘和障碍标志,计算棋盘上最多可以放置多少个骑士,使得它们彼此互不攻击 输入输出格式 输入格式: 第一行有 2 个正整数n 和 m (1<=n<=200, 0<=m<n2),分别表示棋盘的大小和障碍数.接下来的 m 行给出障碍的位置.每行 2 个正整数,表示障碍的方格坐标. 输出格式: 将计算出的共存骑士数输出

[网络流24题] 骑士共存(cogs 746)

骑士共存问题?问题描述:在一个n*n个方格的国际象棋棋盘上,马(骑士)可以攻击的棋盘方格如图所示.棋盘 上某些方格设置了障碍,骑士不得进入. ?编程任务:对于给定的n*n个方格的国际象棋棋盘和障碍标志,计算棋盘上最多可以放置多少个骑士,使得它们彼此互不攻击.?数据输入:由文件knight.in给出输入数据.第一行有2 个正整数n 和m (1<=n<=200, 0<=m<=n*n)<n2),< span="">分别表示棋盘的大小和障碍数.接下来的

[COGS746] [网络流24题] 骑士共存

★★☆   输入文件:knight.in   输出文件:knight.out   简单对比 时间限制:1 s   内存限制:128 MB 骑士共存问题 «问题描述: 在一个n*n个方格的国际象棋棋盘上,马(骑士)可以攻击的棋盘方格如图所示.棋盘 上某些方格设置了障碍,骑士不得进入. «编程任务: 对于给定的n*n个方格的国际象棋棋盘和障碍标志,计算棋盘上最多可以放置多少个骑 士,使得它们彼此互不攻击. «数据输入: 由文件knight.in给出输入数据.第一行有2 个正整数n 和m (1<=n<

AC日记——[网络流24题]骑士共存 cogs 746

746. [网络流24题] 骑士共存 ★★☆   输入文件:knight.in   输出文件:knight.out   简单对比时间限制:1 s   内存限制:128 MB 骑士共存问题 «问题描述: 在一个n*n个方格的国际象棋棋盘上,马(骑士)可以攻击的棋盘方格如图所示.棋盘 上某些方格设置了障碍,骑士不得进入. «编程任务: 对于给定的n*n个方格的国际象棋棋盘和障碍标志,计算棋盘上最多可以放置多少个骑 士,使得它们彼此互不攻击. «数据输入: 由文件knight.in给出输入数据.第一行

[网络流24题] 骑士共存

746. [网络流24题] 骑士共存 ★★☆   输入文件:knight.in   输出文件:knight.out   简单对比 时间限制:1 s   内存限制:128 MB 骑士共存问题 «问题描述: 在一个n*n个方格的国际象棋棋盘上,马(骑士)可以攻击的棋盘方格如图所示.棋盘 上某些方格设置了障碍,骑士不得进入. «编程任务: 对于给定的n*n个方格的国际象棋棋盘和障碍标志,计算棋盘上最多可以放置多少个骑 士,使得它们彼此互不攻击. «数据输入: 由文件knight.in给出输入数据.第一

【wikioi】1922 骑士共存问题(网络流/二分图匹配)

用匈牙利tle啊喂?和网络流不都是n^3的吗.... (更新:what!!!!!!发现个无语的问题,.!!!!结构比数组快啊orz,这节奏不对啊....以后图都写结构的节奏啊... #include <cstdio> #include <cstring> #include <cmath> #include <string> #include <iostream> #include <algorithm> using namespace

P3355 骑士共存问题 二分建图 + 当前弧优化dinic

P3355 骑士共存问题 题意: 也是一个棋盘,规则是“马”不能相互打到. 思路: 奇偶点分开,二分图建图,这道题要注意每个点可以跑八个方向,两边都可以跑,所以边 = 20 * n * n. 然后dinic 要用当前弧优化. #include <algorithm> #include <iterator> #include <iostream> #include <cstring> #include <cstdlib> #include <