2016 Multi-University Training Contest 7

打的心烦意乱，打的时候一直在被打扰，最后干脆走了
慢慢补题，实在是不太想写这场，但是前面的都没写完，都慢慢补吧

http://acm.hdu.edu.cn/showproblem.php?pid=5810
一号题： 数学题
Balls and Boxes
n个球放到m 个盒子里面，求V得期望，V打开上面的链接看吧
反正我不知道怎么推，找规律也找不出来

能力有限，力不从心

二号题：
Joint Stacks

第一次的想法：
开a,b,c，三个数组，用来模拟栈
然后每次push ，c 也放一份
然后碰到merge我们就把c 往a，b放 但是必然有一个for
这一次merge就On 了
而且每一次merge 要把前面所有的 push 进来的值 都要扫一遍，必然会超时

真是蠢，我们其实根本没必要把C里面的东西往a，b放
我们只需要把a,b清空 ，因为题目中说了，不会对空的栈 进行pop操作
所以我们只要碰到pop操作 ，如果a，b 是空栈，那么我们直接对c pop 即可

因为merge 相当于把所有以前还存在的值放在 a 或者 b 栈里面，我们其实不需要
知道是a还是b，因为我们 如果pop某个栈 ，而这个栈是空的，就肯定往c pop
因为题目中告诉你了，不会对空栈 pop

再说说复杂度的问题，这样做的 话每一次merge 只需要对前面一部分的数值进行
归并排序， 而不需要前面所有的值都进行排序
所有的值都只进行一遍归并排序，时间复杂度大概就是 O（n）

#include <cstring>
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <stack>
#include <vector>
#include <queue>
using namespace std;
#define N 105
#define met(a, b) memset(a, b, sizeof(a))

typedef long long LL;

struct node
{
    int Id, num;
    node(){}
    node(int Id, int num) : Id(Id), num(num){}
};
node a[100005],b[100005],c[100005],t[100005];
char s1[15], s2[15];
int main()
{
    int n, Case = 1;
    while(~scanf("%d", &n) && n)
    {
        int lena=0,lenb=0,lenc=0,lent=0;
        printf("Case #%d:\n",Case++);
        for(int i=1; i<=n; i++)
        {
            int num;
            scanf("%s", s1);
            if(strcmp(s1, "push") == 0)
            {
                scanf("%s %d", s2, &num);
                if(s2[0] == 'A')
                    a[++lena]=node(i, num);
                else
                    b[++lenb]=node(i, num);
            }
            else if(strcmp(s1, "pop") == 0)
            {
                scanf("%s", s2);
                if(s2[0] == 'A'){
                    if(lena>0){
                        node p = a[lena];lena--;
                        printf("%d\n", p.num);
                    }
                    else{
                        node p = c[lenc];lenc--;
                        printf("%d\n", p.num);
                    }
                }
                else
                {
                    if(lenb>0){
                        node p = b[lenb];lenb--;
                        printf("%d\n", p.num);
                    }
                    else{
                        node p = c[lenc];lenc--;
                        printf("%d\n", p.num);
                    }
                }
            }
            else
            {
                node p, q;
                scanf("%s %s", s1, s2);
                while(lena>0 && lenb>0)
                {
                    /*
                     这里还需要注意：
                     归并排序的过程中
                     因为栈里面先pop出来的都是 i 值比较大的
                     所以我们t先放进去的都是i比较大的 t是一个逆序的栈
                     我们就把t一个一个反过来 放到C里面， 最多也就O（2n）
                     */
                    p = a[lena];
                    q = b[lenb];
                    if(p.Id > q.Id){
                        t[++lent]=p;
                        lena--;
                    }
                    else{
                        t[++lent]=q;
                        lenb--;
                    }
                }
                while(lena>0)
                {
                    p = a[lena];
                    lena--;
                    t[++lent]=p;
                }
                while(lenb>0)
                {
                    p = b[lenb];
                    lenb--;
                    t[++lent]=p;
                }

                while(lent>0)
                {
                    p = t[lent];
                    lent--;
                    c[++lenc]=p;
                }
            }
        }
    }
    return 0;
}

三号题
Elegant Construction
今天想了一会就A了，当时想都没怎么仔细想，一点心情都没有
可是现在说这个有什么用呢
有向图
题目就是给你几个城市，告诉你每个城市可以到达几个城市，问你能不能构成一个没有环 的图，满足这些条件

其实很简单：
你想如果不构成环，那么最多的边就是 n-1 …n-2…….. 1 …0
也就是可达城市最多的点 最多是n-1 个城市 以此类推
那我们只要把这些城市数值从小到大排序
然后没个城市 可达城市数 f[i].v 必须小于 他前面 的城市总数
为什么 ， 因为他如果和后面的城市相连接了，那么就成环了，如果后面的城市不和他相连？ 那么就不可能排列在他的后面
判断yes或者no ，我们就按照这个建边就好
建边当然是从最后面往前面建。

#include <cstring>
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <stack>
#include <vector>
#include <queue>
using namespace std;

struct node{
    int i;
    int v;
}f[1005];
bool cmp(node a,node b){
    return a.v<b.v;
}
int main()
{
   int t;
   scanf("%d",&t);
   for(int cas=1;cas<=t;cas++){
       printf("Case #%d: ",cas);
       int n;
       scanf("%d",&n);
       for(int i=1;i<=n;i++)
           scanf("%d",&f[i].v),f[i].i=i;
       sort(f+1,f+n+1,cmp);
       int ans=0;
       int flag=1;
       for(int i=1;i<=n;i++){
           if(f[i].v > i-1){
               flag=0;
               break;
           }
           ans+=f[i].v;
       }
       if(!flag){
           printf("No\n");
           continue;
       }
       printf("Yes\n%d\n",ans);
       for(int i=1;i<=n;i++){
           for(int j=1;j<=f[i].v;j++)
               printf("%d %d\n",f[i].i,f[j].i);
       }
   }
    return 0;
}