BZOJ3171: [Tjoi2013]循环格

题解:

从一个点出发回到这个点?

那我们就把每个点拆成两个点i,i’

开始连边 s 到 i’,i 到 t。

相邻的连边 j‘ 到 i,费用等于方向改变的话就是1,否则为0。

然后跑费用流就可以了。

代码:

  1 #include<cstdio>
  2
  3 #include<cstdlib>
  4
  5 #include<cmath>
  6
  7 #include<cstring>
  8
  9 #include<algorithm>
 10
 11 #include<iostream>
 12
 13 #include<vector>
 14
 15 #include<map>
 16
 17 #include<set>
 18
 19 #include<queue>
 20
 21 #include<string>
 22
 23 #define inf 1000000000
 24
 25 #define maxn 200000+5
 26
 27 #define maxm 200000+5
 28
 29 #define eps 1e-10
 30
 31 #define ll long long
 32
 33 #define pa pair<int,int>
 34
 35 #define for0(i,n) for(int i=0;i<=(n);i++)
 36
 37 #define for1(i,n) for(int i=1;i<=(n);i++)
 38
 39 #define for2(i,x,y) for(int i=(x);i<=(y);i++)
 40
 41 #define for3(i,x,y) for(int i=(x);i>=(y);i--)
 42
 43 #define for4(i,x) for(int i=head[x],y=e[i].go;i;i=e[i].next,y=e[i].go)
 44
 45 #define for5(n,m) for(int i=1;i<=n;i++)for(int j=1;j<=m;j++)
 46
 47 #define mod 1000000007
 48
 49 using namespace std;
 50
 51 inline int read()
 52
 53 {
 54
 55     int x=0,f=1;char ch=getchar();
 56
 57     while(ch<‘0‘||ch>‘9‘){if(ch==‘-‘)f=-1;ch=getchar();}
 58
 59     while(ch>=‘0‘&&ch<=‘9‘){x=10*x+ch-‘0‘;ch=getchar();}
 60
 61     return x*f;
 62
 63 }
 64 int n,m,k,mincost,tot=1,s,t,a[20][20],b[20][20][2],head[maxn],d[maxn],from[2*maxm];
 65
 66 bool v[maxn];
 67
 68 queue<int>q;
 69
 70 struct edge{int from,go,next,v,c;}e[2*maxm];
 71
 72 void add(int x,int y,int v,int c)
 73
 74 {
 75
 76     e[++tot]=(edge){x,y,head[x],v,c};head[x]=tot;
 77
 78     e[++tot]=(edge){y,x,head[y],0,-c};head[y]=tot;
 79
 80 }
 81
 82 bool spfa()
 83
 84 {
 85
 86     for (int i=0;i<=t;i++){v[i]=0;d[i]=inf;}
 87
 88     q.push(s);d[s]=0;v[s]=1;
 89
 90     while(!q.empty())
 91
 92     {
 93
 94         int x=q.front();q.pop();v[x]=0;
 95
 96         for (int i=head[x],y;i;i=e[i].next)
 97
 98          if(e[i].v&&d[x]+e[i].c<d[y=e[i].go])
 99
100          {
101
102             d[y]=d[x]+e[i].c;from[y]=i;
103
104             if(!v[y]){v[y]=1;q.push(y);}
105
106          }
107
108     }
109
110     return d[t]!=inf;
111
112 }
113 const int dx[4]={0,0,-1,1};
114 const int dy[4]={-1,1,0,0};
115 inline int id(char ch)
116 {
117     if(ch==‘L‘)return 0;
118     if(ch==‘R‘)return 1;
119     if(ch==‘U‘)return 2;
120     if(ch==‘D‘)return 3;
121     return -1;
122 }
123
124 void mcf()
125
126 {
127
128     mincost=0;
129
130     while(spfa())
131
132     {
133
134         int tmp=inf;
135
136         for(int i=from[t];i;i=from[e[i].from]) tmp=min(tmp,e[i].v);
137
138         mincost+=d[t]*tmp;
139
140         for(int i=from[t];i;i=from[e[i].from]){e[i].v-=tmp;e[i^1].v+=tmp;}
141
142     }
143
144 }
145 int main()
146
147 {
148
149     freopen("input.txt","r",stdin);
150
151     freopen("output.txt","w",stdout);
152
153     n=read();m=read();s=2*n*m;t=s+1;
154     for0(i,n-1)for0(j,m-1)
155     {
156         char ch=getchar();
157         while(id(ch)==-1)ch=getchar();
158         a[i][j]=id(ch);
159         b[i][j][0]=i*m+j;b[i][j][1]=b[i][j][0]+n*m;
160         add(s,b[i][j][1],1,0);add(b[i][j][0],t,1,0);
161     }
162     for0(i,n-1)for0(j,m-1)for0(k,3)
163     {
164         int x=(i+dx[k]+n)%n,y=(j+dy[k]+m)%m;
165         if(x<0||x>=n||y<0||y>=m)continue;
166         add(b[i][j][1],b[x][y][0],1,a[i][j]!=k);
167     }
168     mcf();
169     cout<<mincost<<endl;
170
171     return 0;
172
173 }  

3171: [Tjoi2013]循环格

Time Limit: 1 Sec  Memory Limit: 128 MB
Submit: 499  Solved: 287
[Submit][Status]

Description

一个循环格就是一个矩阵,其中所有元素为箭头,指向相邻四个格子。每个元素有一个坐标(行,列),其中左上角元素坐标为(0,0)。给定一个起始位置(r,c)

,你可以沿着箭头防线在格子间行走。即如果(r,c)是一个左箭头,那么走到(r,c-1);如果是右箭头那么走到(r,c+1);如果是上箭头那么走到
(r-1,c);如果是下箭头那么走到(r+1,c);每一行和每一列都是循环的,即如果走出边界,你会出现在另一侧。
一个完美的循环格是这样定义的:对于任意一个起始位置,你都可以i沿着箭头最终回到起始位置。如果一个循环格不满足完美,你可以随意修改任意一个元素的箭头直到完美。给定一个循环格,你需要计算最少需要修改多少个元素使其完美。

Input

第一行两个整数R,C。表示行和列,接下来R行,每行C个字符LRUD,表示左右上下。

Output

一个整数,表示最少需要修改多少个元素使得给定的循环格完美

Sample Input

3 4
RRRD
URLL
LRRR

Sample Output

2

HINT

1<=R,L<=15

时间: 2024-08-13 02:42:18

BZOJ3171: [Tjoi2013]循环格的相关文章

BZOJ 3171: [Tjoi2013]循环格( 费用流 )

每个点都在某个环中, 出度都为1, 只要让入度也全为1就可以满足题意了. 然后就是裸的最小费用最大流了. ---------------------------------------------------------------------------- #include<cstdio> #include<cstring> #include<algorithm> #include<deque> #include<bitset> using n

bzoj 3171: [Tjoi2013]循环格

1 #include<cstdio> 2 #include<iostream> 3 #include<cstring> 4 #define M 10000 5 #define inf 2139062143 6 using namespace std; 7 int cnt=1,n,m,ans,T,d[M],q[2*M],f[M],head[M],next[10*M],u[10*M],v[10*M],w[10*M],fro[10*M],fr[M]; 8 int mp[100

【BZOJ 3171】 [Tjoi2013]循环格

Description 一个循环格就是一个矩阵,其中所有元素为箭头,指向相邻四个格子.每个元素有一个坐标(行,列),其中左上角元素坐标为(0,0).给定一个起始位置(r,c) ,你可以沿着箭头防线在格子间行走.即如果(r,c)是一个左箭头,那么走到(r,c-1);如果是右箭头那么走到(r,c+1):如果是上箭头那么走到(r-1,c):如果是下箭头那么走到(r+1,c):每一行和每一列都是循环的,即如果走出边界,你会出现在另一侧.一个完美的循环格是这样定义的:对于任意一个起始位置,你都可以i沿着箭

[TJOI2013]循环格

题目链接 戳我 \(Solution\) 我们观察发现循环格要满足每个点的入度都为\(1\) 证明: 我们假设每个点的入读不一定为\(1\),那么必定有一个或多个点的入度为0,那么则不满足循环格的定义,所以假设错误.所以每个点的入度必然为1. 所以这样我们就可以开始建图了.先进行拆点操作,将每个点拆成\(x\)和\(x'\)将\(x\)和\(S\)连接,流量为\(1\),费用为\(0\)再将\(x'\)和\(T\)连接,流量为\(1\),费用为\(0\) 最后对于每个点\(x\)将它和四周的\(

bzoj 3171 [Tjoi2013]循环格(MCMF)

[题目链接] http://www.lydsy.com/JudgeOnline/problem.php?id=3171 [题意] 给定一个方向矩阵,要求改变最少的格子,使得任意一个点都在一个环中. [思路] 任意一个点位于一个环中,即等价于所有的点都有且仅有一个后继. 对于一个点构建X Y结点. 连边(S,Xi,1,0),(Yi,T,1,0).对于原来可以转移到的点连边(Xi,Yj,1,0),对于需要变换才能转移到的连边(Xi,Yk,1,1). 求最小费用最大流.最大流保证了每一个点都会有一个后

BZOJ 3171 循环格(费用流)

题目链接:http://61.187.179.132/JudgeOnline/problem.php?id=3171 题意: 思路:若能构成循环,则每个格子的入度出度 均为1.因此将每个点拆成两个点x1,x2,分别作为出点和入点.出点向周围四个点的入点连边,流1,费用视该格子的字母而定.该格子的字母正好是这个方 向则费用为0否则为1.原点S向每个出点连边,流量1费用0:每个入点向汇点连边,流量1费用0.求最小费用最大流即可. struct node { int u,v,next,cost,cap

【BZOJ】【3171】【TJOI2013】循环格

网络流/费用流 最后能走回出发点……说明全部是环= = 而二分图上的环说明什么呢……完备匹配 对于每个点,它都有四个可能的匹配点,且已知它已经(伪)匹配的一个点,那么我们于已知每条(伪)匹配边,我们连(i,j)->(x,y)' 流量为1,费用为0,表示不用修改,然后对(x,y)'我们向另外三个可能的匹配点连边,流量为1,费用为1,表示修改这个点的匹配对象的代价. 然后对于每个点连S->(i,j) 流量为1,费用为0,(i,j)'->T,流量为1,费用为0.保证每个点有且仅有一个匹配点 1

BZOJ 3171 循环格

重点:如果满流一定存在许多个欧拉回路.于是费用流. #include<iostream> #include<cstdio> #include<queue> #include<cstring> #include<algorithm> #define maxv 500 #define maxe 1000050 #define maxn 20 #define inf 2000000000 using namespace std; int n,m,map

BZOJ 3171 TJOI 2013 循环格 费用流

题目大意:给出一个表格,每个表格指向周围四个格子中的一个,问你可以改变一些格子上的指向,问让所有格子都在圈中最小需要改变多少. 思路:所有的格子都在圈中,由于每个格子只能有一个出边,所以就要保证所有格子都有一个入边.建立费用流的模型,所有点向汇点连流量1费用0的边,表示要接受一个入边.S向所有点连一条流量1费用0的边,表示一条出边.一个格子向周围四个格子连边,流量1,如果方向与当前方向相符,那么费用0,否则费用1.之后跑费用流就是答案了. CODE: #include <queue> #inc