UOJ #56. 【WC2014】非确定机

　　题意大意：给出一个输出文件，求输入。

　　1.满足所求的输入文件是一张图，n个点，m条边，所用算法是k（k在给出的输出文件中给出了）

　　2.算法是图论算法？!k基本上→两位数组成，若十位数相同，说明基本算法可能是相同的。

　　3.给出一个可执行文件，可以在终端中运行自己造出的数据，从而猜测算法。

　　4.你所给出的图不能有重边，但可以有自环，边权<=2*10^4

　　5.p是在给出的输出文件中给定的一个参数，这个参数由你所造出的图由某种计算方式所决定的。

　　

　　先挖坑。。。感觉是一个很有意思的构造+XJB乱搞题，假设是WC的话，我能搞2个半个小时提答，那么。。。。。

　　　

　　闷声滚大粗

　　Notice:这题直接看题解没意思，还是要先做题。。。

---

　　(1)喜闻乐见的01矩阵，再加上样例的那个例子，就是A(i,j)表示是否有i向j连边的意思。

　　

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<vector>
 #include<cstdlib>
 #include<cmath>
 #include<cstring>
 using namespace std;
 #define maxn 10010
 #define llg long long
 #define yyj(a) freopen(a".in","r",stdin),freopen(a".out","w",stdout);
 llg n,m;
 int main()
 {
     yyj("nm1");
     cin>>n;
     llg tot=;
     for (llg i=;i<=n;i++)
         for (llg j=;j<=n;j++)
         {
             llg x;
             //tot++;
             cin>>x;
             if (x) tot++;
             if (x) cout<<i<<" "<<j<<""<<endl;
         }
     cout<<tot;
     return ;
 }

---

　　(2)算法编号k=10，新的图论算法，随便自己造个图用给出的程序试一试发现就是以1为原点的单源最短路，p就是边的数目。

　　　　考虑如何构造：

　　　　1.显然一号点向每个点连一条所要求的权值的边就满足了最短路的条件，但是边数只有n-1条，即p'!=p,可以get 4分。

　　　　2.按照上面的做法打完拿了程序一测正确性发现GG，我之前没看到边权<=2*10^4，好吧，按照所要求的最短路长度排序，按照从小到达的顺序处理，如果小于2*10^4直接和一号点相连，不然找到之前的处理过的点，而且当前点要求的权值减去处理过的点的权值小于等于2*10^4中权值最小的那一个连边，考虑到p的限制，在已经处理过的最小权值的可连边的点之后的点再向待处理的点连出的边将不对答案产生影响。

　　　　

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<vector>
 #include<cstdlib>
 #include<cmath>
 #include<cstring>
 using namespace std;
 #define maxn 10010
 #define llg long long
 #define yyj(a) freopen(a".in","r",stdin),freopen(a".out","w",stdout);
 llg n,m,p,k;
 bool d[maxn][maxn];

 struct node
 {
     llg p,val;
 }a[maxn];
 bool cmp(const node&a,const node&b)  {return a.val<b.val;}
 int main()
 {
     yyj("nm2");
     cin>>n>>k>>p;
     for (llg i=;i<=n;i++)
     {
         a[i].p=i;
         cin>>a[i].val;
     }
     sort(a+,a+n+,cmp);
     p-=n;
     p++;
     for (llg i=;i<=n;i++)
     {
         llg j;
         for (j=;j<i;j++)
             if (a[i].val-a[j].val<=)
             {
                 cout<<a[j].p<<" "<<a[i].p<<" "<<a[i].val-a[j].val<<endl;
                 break;
             }
         j++;
         while (p> && j<i)
         {
             p--;
             cout<<a[j].p<<" "<<a[i].p<<" "<<<<endl;
             j++;
         }
     }
     return ;
 }

---

　　(3)算法编号k=11，嗯，类似于最短路，但是这个点还是要多试试，一开始我认为是求到每个点的不同路径的最短路的数目，我靠不会构啊，再去试了几组数据之后发现：

　　　　　　所求为所有点之间的最短路，但是和边权没有关系，即边权默认为1，p为边数。

　　　沉思。。。。。没办法了打一个暴力，想到优化显然矩阵中为1点的相当于所对应的(x,y)一定连了一条边。再一看有400个1。p也是400，在想想这很显然啊，连出了所有为1的边之后答案就确定了。

　　

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<vector>
 #include<cstdlib>
 #include<cmath>
 #include<cstring>
 using namespace std;
 #define maxn 10010
 #define llg long long
 #define yyj(a) freopen(a".in","r",stdin),freopen(a".out","w",stdout);
 llg n,m,p,k;
 bool d[maxn][maxn];

 struct node
 {
     llg p,val;
 }a[maxn];
 bool cmp(const node&a,const node&b)  {return a.val<b.val;}
 int main()
 {
     yyj("nm3");
     cin>>n>>k>>p;
     cout<<n<<" "<<p<<" "<<k<<endl;
     for (llg i=;i<=n;i++)
     {
         for (llg j=;j<=n;j++)
         {
             llg x;
             cin>>x;
             if (x==) cout<<i<<" "<<j<<""<<endl;
         }
     }
     return ;
 }

---

　　(4)算法编号k=12，最短路。。。似乎是次短路欸，但是第一个点居然有权值，这会在一开始迷惑住我们，但是多试几次就会发现点1的次短路是经过点1的最短环的长度，那么我们考虑构造一个装置增长每个点的路径的长度，这样就类似于第k=10的算法了。

　　

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<vector>
 #include<cstdlib>
 #include<cmath>
 #include<cstring>
 using namespace std;
 #define maxn 10010
 #define llg long long
 #define yyj(a) freopen(a".in","r",stdin),freopen(a".out","w",stdout);
 int d[],v[],q[];
 int i,j,k,n=,m=,P=;
 int main()
 {
     yyj("nm4");
     scanf("%*d %*d %*d");
     for (i=;i<=n;i++){scanf("%d",&d[i]);if (d[i]==) P=i;}
     for (i=;i<=n;i++)
         if (i != P) d[i]-=;
     int tmp=d[];
     j=; d[]=;
     for (int x=; x<=; x++)
     {
         k=j; q[j]=;
         for (i=;i<=;i++)
             if (i!=P && d[i]>d[j] && d[i]<=d[j]+)
             {
                 if (d[i] > d[k]) k=i;
                 printf("%d %d %d\n",j,i,d[i]-d[j]),m++;
                 if (j==) v[i]=;
             }
         j=k;
     }
     d[]=tmp;
     for (i=;i<=n;i++)
         if (d[i]<d[] && d[i]>d[]-) break;
     printf("%d %d %d\n",i,,d[]-d[i]);
     printf("%d %d %d\n",,P,d[P]-d[]);
     m += ;
     for (i=;i<=n;i++)if (v[i]) printf("%d %d %d\n",P,i,d[i]+-d[P]+d[]),m++;
     for (i=;i<=n;i++)
         if (!q[i])
             for (j=; j<=n; j++)
                 if (d[i]+>d[j])
                 {
                     printf("%d %d %d\n",i,j,);
                     m++;
                     if (m==) return ;
                 }
     return ;
 }

---

　　(5)算法编号k=20，新的算法，既然是2.0那么应该是送分的，造几组数据之后发现答案输出了n个数，每一个数都小于n，并且有很多是相同的。考虑一下，这不就是强连通分量么，每一个数字表示他这个点所属于的这个强连通分量的最小点的编号，p是强连通分量的数目，给出的输出中也只有p个不同的数字。那就很好做了，既然和边数没有关系，把属于同一个强连通分量的点拉出来连成一个环就可以了。

　　

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<vector>
 #include<cstdlib>
 #include<cmath>
 #include<cstring>
 using namespace std;
 #define maxn 10010
 #define llg long long
 #define yyj(a) freopen(a".in","r",stdin),freopen(a".out","w",stdout);
 llg n,m,k,p,tot,c[maxn];

 vector<llg>a[maxn];

 int main()
 {
     yyj("nm5");
     cin>>n>>k>>p;
     for (llg i=;i<=n;i++) cin>>c[i];
     for (llg i=;i<=n;i++) a[c[i]].push_back(i);
     for (llg x=;x<=n;x++)
     {
         llg w=a[x].size();
         for (llg i=;i<w;i++)
         {
             tot++;
             cout<<a[x][i]<<" "<<a[x][i-]<<""<<endl;
         }
         if (w>=)
         {
             cout<<a[x][]<<" "<<a[x][w-]<<""<<endl;
             tot++;
         }
     }
     cout<<tot;
     return ;
 }

---

　　(6))算法编号k=21，这个p是个什么鬼，试了试发现之和图的构型有关和权值无关，那么n=8，管他是什么，爆搜就可以了。（考你会不会用终端）

　

---

　　(7)算法编号k=22，又和上面是一个节奏，这次n更大了，GG。。1分走人（挖坑）

　

---

　　(8)算法编号k=30，以为是个水的，但看了数据真是一脸懵逼，搞了好久才发现求的是这个图的匹配数量(一般图最大匹配),没什么技术含量，p=61*100，下面那一行给的是匹配数，那么构一个前面61个点，后面100个点(及所有点)的图出来即可。(一共一百个点）

　　　　

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<vector>
 #include<cstdlib>
 #include<cmath>
 #include<cstring>
 using namespace std;
 #define maxn 10010
 #define llg long long
 #define yyj(a) freopen(a".in","r",stdin),freopen(a".out","w",stdout);
 llg n,m,k,p;
 int main()
 {
     yyj("nm8");
     cin>>n>>k>>p;
     cout<<n<<" "<<p<<" "<<k<<endl;
     for (llg i=;i<=;i++)
         for (llg j=;j<=;j++)
         {
             cout<<i<<" "<<j<<""<<endl;
         }
     return ;
 }

　　　　

---

　　(9)算法编号k=31，把一个点拆成了两个点之后（最小路径覆盖的那种拆分），然后二分图匹配之后对应i位置输出的是匹配到右边的第j个。可是方案不止一种.

　　以上口胡，求的是字典序最小的排列,使得(i,xi)有边。尝试发现是字典序最小的。

　　

　　

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<vector>
 #include<cstdlib>
 #include<cmath>
 #include<cstring>
 using namespace std;
 #define llg long long
 #define maxn 2010
 #define yyj(a) freopen(a".in","r",stdin),freopen(a".out","w",stdout);
 llg n,m,p,f[maxn],k[maxn][maxn];
 int main()
 {
     yyj("nm9");
     scanf("%lld %*d %lld", &n, &m);
     for (llg i=;i<=n;i++) scanf("%lld",&f[i]);
     for (llg i=;i<=n; i++)
     {
         for (llg j=;j<i;j++) printf("%lld %lld 1\n",i,f[j]), k[i][f[j]]=;
         for (llg j=f[i];j<=; j++) if (!k[i][j]) printf("%lld %lld 1\n", i, j);
     }
     return ;
 }

---

　　(10)算法k=13，不要问我是怎么奇妙的get到了这个点的意思(大概是spfa选手的缘故？），似乎就是对于这个图的spfa增广队列的顺序，而且这个顺序还是错的(同级增广编号小的点在前）。。。。MDZZ不会啊，拿下1分走人。  挖坑，会了再补。