编程之美2013资格赛 水结

 很久没有在线编程了，实力大大减弱。为了保持算法与编程的技能，继续找一下在线比赛来复习复习。只为找感觉，不求排名与晋级。

一 传话游戏

http://programming2013.cstnet.cn/qualification/problem/1

题目简意：一句由若干个单词组成的话，经过N个人传承。每个人在听取前一个人的口述时，都会把某些单词听成另外的单词。求最终被流传下来的句子。

解： 不能再水了，就是简单的字符串替换。不想用c写字符串的东西，于是用了java的HashMap<String,String>，还是第一次用java提交。注意类名一定要是Main

 
import java.util.HashMap;
import java.util.Scanner;

public class Main{
    
    
public static int T, N, M;

public static int count = 1;
public static HashMap<String,String> rule;

public static String   orignal, result;
public static Scanner cin = new Scanner(System.in);


    public static void main(String[] args){
        
        T = cin.nextInt();
        
        while(T-- > 0)
        {
            N = cin.nextInt();
            M = cin.nextInt();
            result = "";
             
            rule = new HashMap<String,String>();
            for(int i = 0; i < M; i++)
            {
                String ori = cin.next().toString();
                String swp = cin.next().toString();
                rule.put(ori, swp);
            }
            
            orignal = cin.next().toString();
            orignal += cin.nextLine().toString();
             
            
            String[] sentence = orignal.split(" ");
            
            
            while(N > 1)
            {
                for(int i = 0; i < sentence.length; i++)
                    if (rule.containsKey(sentence[i]))
                        sentence[i] = rule.get(sentence[i]);                     
                N--;
            }
            
            String result = "";
            for (int i=0;i<sentence.length;i++)
                result += " "+sentence[i];
            
            System.out.println("Case #" + count++ + ":" + result);
            
        }
    } 

}

二 长方形

http://programming2013.cstnet.cn/qualification/problem/2

题目概要：在 N 条水平线与 M 条竖直线构成的网格中，放 K 枚石子，每个石子都只能放在网格的交叉点上。问在最优的摆放方式下，最多能找到多少四边平行于坐标轴的长方形，它的四个角上都恰好放着一枚石子。 

输入：第一行，给出一个整数T，为数据组数。接下来依次给出每组测试数据。

每组数据为三个用空格隔开的整数 N，M，K。

1 ≤ T ≤ 100

0 ≤ K ≤ N * M

小数据：0 < N, M ≤ 30

大数据：0 < N, M ≤ 30000

解：这是一道排列组合的问题。假设我们已经知道从K个石子中取X*Y个组成一个大的饱满的矩形，它上面每一行的石子数目相同，剩余L个石子，0<L<X。则此时的矩形总数为：在饱满的大矩形中，共有C(x,2)*C(y,2)个小矩形，剩下的和L有关的矩形数是X*C(L,2) 。两者的和即为所求。

如何选取X和Y呢？应该可以理论证明的，但是我懒得去推，因为N，M<= 30000， 可以枚举每一个X的值。（似乎真的太懒了。。。）

#include<stdio.h>
#include<math.h>

unsigned long long solve()
{
    int i,j,k;
    int t,n,m;
    unsigned long long mx = 0;
    int x,y,l;
    unsigned long long cur;
    
    scanf("%d%d%d",&n,&m,&k);
    if (n>m)
    {
        t=n;n=m;m=t;
    }
    for (i=2;i<=n;i++)
    {
        x=i; 
        y = k / i;
        l = k % i;
        if (y>m || y==m && l>0)
          continue;
        cur = x*y*(x-1)*(y-1)/4 + y * (l-1)*l/2;
        if (cur>mx)
          mx = cur;        
    }
    return mx;    
}

int main()
{
    int T,i;
    scanf("%d",&T);
    for (i=1;i<=T;i++)
        printf("Case #%d: %llu\n",i,solve());
    return 0;
}

这个平台和杭电的又有所不同，输出不能用%I64d ,而要用%llu 来输出 unsigned long long。

三 树上的三角形

有一棵树，树上有只毛毛虫。它在这棵树上生活了很久，对它的构造了如指掌。所以它在树上从来都是走最短路，不会绕路。它还还特别喜欢三角形，所以当它在树上爬来爬去的时候总会在想，如果把刚才爬过的那几根树枝/树干锯下来，能不能从中选三根出来拼成一个三角形呢？

1 ≤ T ≤ 5

小数据：1 ≤ N ≤ 100, 1 ≤ M ≤ 100, 1 ≤ len ≤ 10000

大数据：1 ≤ N ≤ 100000, 1 ≤ M ≤ 100000, 1 ≤ len ≤ 1000000000

解：一看就让人想到用最近公共祖先和并查集。但是我现在不想花太多精力去实现它，于是就决定水一下小数据。

首先要说的是，小数据的范围是1000，而不是100！害我检查了N次，太无耻了。

拿到树的结构以后，任取一个节点，遍历一遍树，为了得到每个节点的深度（假设根节点的深度为0）和它的父节点。

然后对每一对节点s和t，沿着他们的父节点一层一层上移，直到遇到第一个公共祖先。（利用每个节点的深度）。并把这条路径上的边压入一个数组中。

接着对保存有边的数组进行排序。遍历一次排序好的数组，如果存在相邻的三条边能构成三角形，那么就yes，否则就no。

#include<stdio.h>
#define size 900
int N,M;
int c[size][size];
int dep[size];
int father[size];
int visited[size];
int edge[size];
int cnt;

void Broadcast(int s, int d  )
{
    int i;
    
    visited[s] = 1;
    dep[s] = d;
    int fa,fb;
    
       
    for (i=1;i<=N;i++)
       if (visited[i]==0 && c[s][i]>0)
       {
          father[i] = s;
          Broadcast(i,d+1 );
       }
}
 
void sort(int s[] , int cnt)
{
    int t;
    int i,j;
    for (i=0;i<cnt;i++)
      for (j=i+1;j<=cnt;j++)
        if (s[i]>s[j])
        {
          t = s[i];
          s[i] = s[j];
          s[j] = t;
        }
}

void solve()
{

    int i,j,k;
    int s,t,w;
    int ok ;
    int fa,fb;
    scanf("%d",&N);
    
    
    for (i=1;i<=N;i++)
    {
      visited[i] = 0;
      for (j=1;j<=N;j++)
      {
         c[i][j] = 0;
         c[j][i] = 0;
         }
    }
    
    for (i=1;i<N;i++)
       {
          scanf("%d %d %d",&s,&t,&w);
          c[s][t] = w;
          c[t][s] = w;
       }
       
    scanf("%d",&M);
    father[1] = 1;
    
    Broadcast(1,0 );
    for (k=0;k<M;k++)
    {
        scanf("%d %d",&s,&t);
    //    printf("No\n");
    //    continue;
        fa = s;
        fb = t;
        cnt = 0;
     
        while (fa != fb)
        {
            if (dep[fa]>dep[fb])
            {
                fa = father[fa];
            }
            else fb = father[fb];
        }
        
        while (s != fa)
        {
            edge[cnt++] = c[s][father[s]];
            s = father[s];
        }
        while (t != fa)
        {
            edge[cnt++] = c[t][father[t]];
            t = father[t];
        }
     
         //qsort(edge,0,cnt-1);
        sort(edge,cnt-1);
        ok = 0;
        for (i=0;i<cnt-2;i++)
        {
            if (edge[i]+edge[i+1] > edge[i+2])
            {
              ok = 1;
              break;
            }
        }
        if (ok==1)
          printf("Yes\n");
          else printf("No\n");
    }
}

int main()
{
    int T;
    int i;
    scanf("%d",&T);
    for (i=1;i<=T;i++)
    {
        printf("Case #%d:\n",i);
        solve();           
    }
    return 0;
}