【2016北京集训测试赛】river

HINT

注意是全程不能经过两个相同的景点，并且一天的开始和结束不能用同样的交通方式。

[吐槽]

　　嗯。。看到这题的想法的话。。先想到了每个点的度为2，然后就有点不知所措了

　　隐隐约约想到了网络流，但并没有继续往下想了。。。

　　听完学长的讲评之后（%xj）个人觉得建图还是很有意思的ovo

[题解]

　　因为每个点到对面都有k种方式，那就想到每个点原来的点$x_0$拆成k个点$x_1$, $x_2$, $x_3$... $x_k$

　　然后很自然地$x_0$和拆成的点之间要连边

　　容量的话，因为hint里面的限制，也就是说一个点到另一个点的k中交通方式中只能选一种

　　（因为每个点只能到一次，而开始和结束不能用同样的方式）

　　这样一来容量显然就应该是1了

　　两岸之间的连接，就直接按照读入左岸连到右岸就好，容量也为1

　　（但其实因为左岸的流入流量和右岸的流出流量都有限制，中间的那条好像容量取1~ $\infty$都可以。。。%yxq）

　　接着考虑最后的答案是怎么得到的，会发现其实我们最后的到的路线是若干个环，每个点的度为2（一个大概长这样的）

　　

　　如此一来，就会有个大胆的想法

　　对于每一个左岸的$x_0$，我们连一条源点到它的容量为2的边

　　对于每一个右岸的$x_0$，我们连一条它到汇点的容量为2的边

　　这样起到一个限制了每个点的度的作用，就可以保证有环并且环内每个点的度都为2（个人感觉这点是很有意思的）

　　

　　于是乎最终的到的图长这样（以样例为例）

　　

　　那么现在考虑构造方案

　　看回之前建图的思路，很容易得到的一个结论是满流的边肯定就是要走的边

　　那么现在问题就变成知道一堆边然后构造方案啦

　　很简单粗暴的方法直接强行把每个环走一遍记录下答案就好

　　天数的话就看有多少个环就好啦

　　挫挫的代码qwq

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<queue>
 #define inf 2147483647
 using namespace std;
 const int MAXN=**+;
 struct xxx
 {
     int y,next,op,r,x;
 }a[MAXN*];
 queue<int> q;
 int h[MAXN],lv[MAXN],id[][],num[MAXN];
 int go[MAXN][],ans[][];
 bool vis[MAXN];
 int n,m,k,vs,vt,tot,tot1;
 int add(int x,int y,int r);
 int bfs();
 int dfs(int v,int o);
 int get_ans();

 int main()
 {
     freopen("a.in","r",stdin);

     int x,y,z;
     scanf("%d%d%d",&n,&m,&k);
     memset(h,-,sizeof(h));
     tot=;
     vs=,vt=MAXN-;
     for (int i=;i<=n+n;++i)
         for (int j=;j<=k;++j)
             id[i][j]=++tot,num[tot]=i;
     tot=;
     for (int i=;i<=n;++i)
     {
         add(vs,id[i][],);
         add(id[i+n][],vt,);
         for (int j=;j<=k;++j)
             add(id[i][],id[i][j],),add(id[i+n][j],id[i+n][],);
     }
     for (int i=;i<=m;++i)
     {
         scanf("%d%d%d",&x,&y,&z);
         add(id[x][z],id[y+n][z],);
     }
     while (bfs()) dfs(vs,inf);
     get_ans();
 }

 int add(int x,int y,int r)
 {
     a[++tot].y=y; a[tot].next=h[x]; h[x]=tot; a[tot].r=r; a[tot].op=tot+;
     a[++tot].y=x; a[tot].next=h[y]; h[y]=tot; a[tot].r=; a[tot].op=tot-;
 }

 int bfs()
 {
     while (!q.empty()) q.pop();
     memset(lv,,sizeof(lv));
     q.push(vs);
     lv[vs]=;
     int v,u;
     while (!q.empty())
     {
         v=q.front(); q.pop();
         for (int i=h[v];i!=-;i=a[i].next)
         {
             u=a[i].y;
             if (lv[u]||!a[i].r) continue;
             q.push(u);
             lv[u]=lv[v]+;
             if (u==vt) return true;
         }
     }
     return false;
 }

 int dfs(int v,int o)
 {
     if (v==vt||o==) return o;
     int u,flow,ret=;
     for (int i=h[v];i!=-;i=a[i].next)
     {
         u=a[i].y;
         if (lv[u]!=lv[v]+) continue;
         flow=dfs(u,min(a[i].r,o));
         if (flow)
         {
             a[i].r-=flow;
             a[a[i].op].r+=flow;
             ret+=flow;
             o-=flow;
             if (!o) break;
         }
     }
     return ret;
 }

 int get_ans()
 {
     int x,y,pre;
     //go[i]记录与i相连的两个点
     for (int i=;i<=n;++i)
         for (int j=;j<=k;++j)
             for (int tmp=h[id[i][j]];tmp!=-;tmp=a[tmp].next)
             {
                 if (a[tmp].r||a[tmp].y==id[i][]) continue;
                 y=num[a[tmp].y];
                 if (!go[i][]) go[i][]=y;
                 else go[i][]=y;

                 if (!go[y][]) go[y][]=i;
                 else go[y][]=i;
             }
     memset(vis,false,sizeof(vis));
     int cnt=;
     for (int i=;i<=n;++i)
     {
         if (vis[i]) continue;
         ++cnt;
         //将每个环走一遍
         pre=i,x=go[i][];
         ans[cnt][++ans[cnt][]]=i;
         vis[i]=true;
         while (x!=i)
         {
             vis[x]=true;
             ans[cnt][++ans[cnt][]]=x;
             if (pre==go[x][]) pre=x,x=go[x][];
             else pre=x,x=go[x][];
         }
         ans[cnt][++ans[cnt][]]=x;
     }
     printf("%d\n",cnt);
     //因为建图的方式所以左右岸肯定是交错来的
     for (int i=;i<=cnt;++i)
     {
         printf("%d ",ans[i][]);
         for (int j=;j<=ans[i][];++j)
             if (j&) printf("L%d ",ans[i][j]);
             else printf("R%d ",ans[i][j]-n);
         printf("\n");
     }
 }