Astronomers often examine star maps where stars are represented by points on a plane and each star has Cartesian coordinates. Let the level of a star be an amount of the stars that are not higher and not to the right of the given star. Astronomers want to know the distribution of the levels of the stars.

For example, look at the map shown on the figure above. Level of the star number 5 is equal to 3 (it's formed by three stars with a numbers 1, 2 and 4). And the levels of the stars numbered by 2 and 4 are 1. At this map there are only one star of the level 0, two stars of the level 1, one star of the level 2, and one star of the level 3.

You are to write a program that will count the amounts of the stars of each level on a given map.

Input

Output

Sample Input

5
1 1
5 1
7 1
3 3
5 5

Sample Output

1
2
1
1
0

解题思路
题意：
题目不长，很容易理解，自己看- -
思路：
让我们来看树状数组的第一个题。有关树状数组请看：http://hi.baidu.com/narutoacm/blog/item/fd514c0d9d58c7266059f3a9.html或者：http://www.cppblog.com/NARUTOACM/archive/2010/03/21/110186.html
题目告诉我们输入是按照y的大小从小到大输入的，如果y相等就按照x大小从小到大输入，这无疑为我们提供了方便。当我们考虑某点时，显然我们可以只看在该点前面出现的点中的x坐标，当点的x坐标小于该点的x坐标时，显然点被该点覆盖。于是我们可以用树状数组很快的统计出所有的点覆盖了多少点(包括本身)，即等级为多少。由于坐标下限是0，所以插入和统计的时候都+1.源代码如下：
源程序

#include<iostream>
#include<algorithm>
using namespace std;
int N;
int C[32005];
int X[15005];
int p[15005];
int lowbit(int x)
{
    return x&(x^(x-1));
}
void add(int i,int value)
{
    while(i<=32001)
    {
        C[i]+=value;
        i+=lowbit(i);
    }
}
int SUM(int i)
{
    int sum=0;
    while(i>0)
    {
        sum+=C[i];
        i-=lowbit(i);
    }
    return sum;
}
int main()
{
    int i;
    int x,y;
    while(scanf("%d",&N)!=EOF)
    {
        for(i=1;i<=N;i++)
        {
            scanf("%d%d",&x,&y);
            X[i]=x;
        }
        for(i=1;i<=N;i++)
        {
            add(X[i]+1,1);
            p[SUM(X[i]+1)-1]++;
        }
        for(i=0;i<N;i++)
            printf("%d\n",p[i]);
        memset(p,0,sizeof(p));
    }
    return 0;
}

Input

Output

Sample Input

10
4 5 3 7 2 8 1 6 10 9
1 Hello Bob
1995 CERC
0
0

Sample Output

BolHeol  b
C RCE

解题思路
题意：
告诉你加密方式，让你按照那方式编码。
思路：
模拟题，不过纯模拟的话有可能会TLE，我们可以先算出周期T，然后就可以去秒了。源代码如下：
源程序

#include<iostream>
using namespace std;
int n,k;
int p[205];
char s[205];
char s2[205];
int T[205];
int main()
{
    int i,j;
    while(scanf("%d",&n)&&n)
    {
        for(i=1;i<=n;i++)
            scanf("%d",&p[i]);
        for(i=1;i<=n;i++)
        {
            int c=1;
            j=i;
            while(p[j]!=i)
            {
                c++;
                j=p[j];
            }
            T[i]=c;
        }
        while(scanf("%d",&k)&&k)
        {
            getchar();
            gets(s+1);
            int m=-1;
            int len=strlen(s+1);
            for(i=1;i<=n;i++)
                s2[i]=' ';
            for(i=1;i<=len;i++)
            {
                int x=k%T[i];
                int j=i;
                while(x--)
                    j=p[j];
                s2[j]=s[i];
                if(j>m)
                    m=j;
            }
            for(i=1;i<=m;i++)
                s[i]=s2[i];
            s[m+1]='\0';
            printf("%s\n",s+1);
        }
        printf("\n");
    }
    return 0;
}

Input

Output

Sample Input

2
3 3
3 1 2 3
2 1 2
1 1
3 3
2 1 3
2 1 3
1 1

Sample Output

YES
NO

解题思路
题意：
学生选课，要求没门课都有人选，而且选的学生都是愿意选这门课的，学生可以选择选或不选，选的话就选自己想选的课。问这样的选课关系能不能满足上述条件，满足输出YES，否则输出NO。
思路：
显然的2分图匹配，匹配数=课数即为YES，否则为NO。只会匈牙利算法，但是貌似效率有点低，407MS....看来要学别的算法了的说.....源代码如下：
源程序

#include<iostream>
using namespace std;
int P,N;
int Map[105][305];
int visit[305];
int prematch[305];
int match;
bool crosspath(int k)
{
    int i;
    for(i=1;i<=Map[k][0];i++)
    {
        if(!visit[Map[k][i]])
        {
            visit[Map[k][i]]=1;
            if(!prematch[Map[k][i]]||crosspath(prematch[Map[k][i]]))
            {
                prematch[Map[k][i]]=k;
                return true;
            }
        }
    }
    return false;
}
void hungray()
{
    int i;
    for(i=1;i<=P;i++)
    {
        if(crosspath(i))
            match++;
        memset(visit,0,sizeof(visit));
    }
}
int main()
{
    int T,i,j,c;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&P,&N);
        for(i=1;i<=P;i++)
        {
            Map[i][0]=0;
            scanf("%d",&c);
            for(j=1;j<=c;j++)
                scanf("%d",&Map[i][++Map[i][0]]);
        }
        hungray();
        if(match==P)
            printf("YES\n");
        else
            printf("NO\n");
        match=0;
        memset(prematch,0,sizeof(prematch));
    }
    return 0;
}

Input

Output

Sample Input

5 5 10
0 1 1
1 1 2
2 1 3
3 1 4
4 2 1
5 2 2
6 2 3
7 2 4
8 3 3
9 4 3
0

Sample Output

3

 
解题思路
题意：
有任务和两个机器，每个机器有他的几种工作模式，每一种任务都可以由两个机器的一种模式来加工。机器开始是在0模式，每换一次模式要重启一次，所以要通过安排任务的执行顺序来使得重启数量最少并且完成所有任务，求最少的重启数量。
思路：
以任务作为边，机器的模式为点。如果一任务可以由A机器的模式i或B机器的模式j加工，那么ij连边，边代表该任务。于是问题变成了求以最少的点来覆盖所有边的问题，即最小点覆盖，即可在转变成由求最大匹配得到。运用著名的匈牙利算法即可快速的求解该问题。需要注意的是由于机器开始都处于0模式，所以如果有任务可以有任一种机器的0模式加工的话可先直接加工该任务而不要重启机器，即不要连边。源代码如下：
源程序

#include<iostream>
using namespace std;
int n,m,k;
int Map[110][110];
int match;
int use[110];
int mat[110];
bool crosspath(int k)
{
    int i,j;
    for(i=1;i<=Map[k][0];i++)
    {
        j=Map[k][i];
        if(!use[j])
        {
            use[j]=1;
            if(mat[j]==-1||crosspath(mat[j]))
            {
                mat[j]=k;
                return true;
            }
        }
    }
    return false;
}
void hungary()
{
    int i;
    for(i=0;i<n;i++)
    {
        if(crosspath(i))
            match++;
        memset(use,0,sizeof(use));
    }
}
int main()
{
    int i,j,x,y;
    while(scanf("%d",&n)&&n)
    {
        scanf("%d%d",&m,&k);
        memset(mat,-1,sizeof(mat));
        for(i=0;i<n;i++)
        {
            for(j=0;j<m;j++)
                Map[i][j]=0;
        }
        for(j=1;j<=k;j++)
        {
            scanf("%d%d%d",&i,&x,&y);
            if(x*y==0)
                continue;
            Map[x][++Map[x][0]]=y;
        }
        hungary();
        printf("%d\n",match);
        match=0;
    }
    return 0;
}

Input

Output

Sample Input

4
A
B
C
D
5
laptop B
phone C
pager B
clock B
comb X
3
B X
X A
X D 

Sample Output

1

解题思路
题意：
有插座用电器和适配器，用电器有插头，适配器本身有一个插孔和插头，它的作用是可以把别的插头插入到适合该适配器插孔的适配器，然后就可以用适配器的插头接到适合的插座，相当于转换插头的作用。每个插座只能插入一个插头。3种东西都最多有100个，但是任一种适配器可以有无限个。问最后最少能剩下几个用电器不能用上电。
思路：
每一种插头看成一个点，注意是每一种，每一个用电器看成一个点，注意是每一个，然后构图。用电器可以插入对应的插座，所以该用电器这个点可以和该插座对应的插头种类这个点连线，权为1。由于适配器有无数个，所以适配器的插孔对应的插头和适配器的插头连线，权为INF。自取源点汇点，令源点和所有用电器连线，权为1，n个插座对应的插头与汇点相连，权为1.以sample为例，绘图如下：



源程序

#include<iostream>
#include<queue>
#include<map>
#include<string>
using namespace std;
int Map[502][502];
int n,m,k;
map<string,int>M;
int t;
int S,T,F;
int pre[502];
queue<int>Q;
void addFlow(int d)
{
    int i=T;
    int j=pre[T];
    while(i!=S)
    {
        Map[i][j]+=d;
        Map[j][i]-=d;
        i=j;
        j=pre[i];
    }
    F+=d;
}
void fulk()
{
    int i;
    while(1)
    {
        memset(pre,-1,sizeof(pre));
        while(!Q.empty())
            Q.pop();
        Q.push(S);
        while(!Q.empty())
        {
            int ns=Q.front();Q.pop();
            for(i=0;i<=T;i++)
            {
                if(Map[ns][i]>0&&pre[i]==-1)
                {
                    pre[i]=ns;
                    Q.push(i);
                }
            }
            if(pre[T]!=-1)
                break;
        }
        if(pre[T]!=-1)
            addFlow(1);
        else
            return;
    }
}
int main()
{
    int i;
    char temp[25],name[25];
    string s;
    scanf("%d",&n);
    for(i=1;i<=n;i++)
    {
        scanf("%s",name);
        s=name;
        M[s]=i;
    }
    t=n;
    scanf("%d",&m);
    for(i=1;i<=m;i++)
    {
        scanf("%s %s",temp,name);
        s=name;
        if(M.find(s)==M.end())
        {
            t++;
            M[s]=t;
        }
        Map[i][m+M[s]]=1;
    }
    scanf("%d",&k);
    for(i=1;i<=k;i++)
    {
        scanf("%s %s",temp,name);
        s=temp;
        if(M.find(s)==M.end())
        {
            t++;
            M[s]=t;
        }
        s=name;
        if(M.find(s)==M.end())
        {
            t++;
            M[s]=t;
        }
        string ss=temp;
        Map[m+M[ss]][m+M[s]]=99999999;
    }
    S=0;T=m+t+1;F=0;
    for(i=1;i<=m;i++)
        Map[S][i]=1;
    for(i=1;i<=n;i++)
        Map[m+i][T]=1;
    fulk();
    printf("%d\n",m-F);
    return 0;
}

Input

Output

Sample Input

3 4
daababac

Sample Output

5

解题思路
题意：
N代表子串长度，NC代表串中不同字符的个数，求母串中含有多少个不同的子串。
思路：
不难想到可以用NC进制数表示子串，直接hash。有一点可能会纠结，题目没说串中只有小写字母，还可能是很多不同的字符，所以去-'a'的tx要注意了。关于这个问题我的办法是先处理母串，把母串扫描一遍，把不同的字符都分别赋值到一个数组，计算的时候直接用就可以了。也许扫描要费时间等，反正程序很垃圾，用了94MS。源代码如下：
源程序

#include<iostream>
using namespace std;
__int64 N,NC;
char p[100000000];
int hash[100000000];
int a[10000];
int main()
{
    int i,j;
    scanf("%d%d",&N,&NC);
    scanf("%s",p);
    int len=strlen(p);
    __int64 sum;
    int ans=0;
    int count=0;
    for(i=0;i<len;i++)
    {
        if(!a[p[i]])
            a[p[i]]=++count;
    }
    for(i=0;i<len-N+1;i++)
    {
        sum=0;
        for(j=i;j<i+N;j++)
            sum=sum*NC+a[p[j]];
        if(!hash[sum])
        {
            ans++;
            hash[sum]=1;
        }
    }
    printf("%d\n",ans);
    return 0;
}

Input

Output

Sample Input

100 7
1 101 1
2 1 2
2 2 3
2 3 3
1 1 3
2 3 1
1 5 5

Sample Output

3

解题思路
题意：
中文别跟我说你看不懂除非你是外国人那么很抱歉我无法把这篇文章翻译成英语。(这句话好长。。)
思路：
并查集的应用。
p(x)为x所属树的根节点。kind(x)为x与该树根节点的关系。rank(x)为树x的高度。现在规定：
0：同类关系。
1：吃关系。
2：被吃关系。
我们用x--r-->y表示x和y之间的关系是r，比如x--1--y代表x吃y。现在，若已知x--r1-->y，y--r2-->z，如何求x--?-->z？，于是我们不难发
现，x--(r1+r2)%3-->z。有了这个结论，我们就可以做题了。
我们初始化kind(1-N)=0，表示自己和自己为同类。P(1-N)=i，代表各个节点都是一棵树。当D X Y时，则应合并X的根节点和Y的根节点，
同时修改各自的kind。那么问题来了，合并了之后，被合并的根节点的kind值如何变化呢？
现有x和y，d为x和y的关系，px和py分别是x和y的根节点，于是我们有x--kind[x]-->px，y--kind[y]-->py，显然我们可以得到
px--(3-kind[x])-->x，py--(3-kind[y])-->y。假如合并后px为新的树的根节点，那么原先px树上的节点不需变化，py树则需改变了，因为kind
值为该节点和树根的关系。这里只改变kind(py)即可，因为在进行find_set操作时可相应改变py树的所有节点的kind值。于是问题变成了
py--?-->px。我们不难发现py--(3-kind[y])-->y--(3-d)-->x--kind[x]-->px，根据前面的结论，我们有py--(3-kind[y]+3-d+kind[x])%3-->px。我们
求解了px和py的关系了。
那么AC之就变得简单了，于是：源代码如下：
源程序
//rank数组只是用于启发式合并过程，其实不要那个rank速度还更快些，因为我这里的union_set只改变了根节点，所以rank无任何作用，
大家大可把他去掉。
#include<iostream>
using namespace std;
int p[50001],kind[50001],rank[50001];
int N,K,D,X,Y;
void make_set(int N)
{
 int i;
 for(i=1;i<=N;i++)
  p[i]=i,rank[i]=kind[i]=0;
}
int find_set(int x)
{
 if(x==p[x])
  return x;
 int temp=p[x];
 p[x]=find_set(p[x]);
 kind[x]=(kind[x]+kind[temp])%3;
 return p[x];
}
void union_set(int px,int py,int x,int y,int d)
{
 if(rank[px]>rank[py])
 {
  p[py]=px;
  kind[py]=(3-kind[y]+3-d+kind[x])%3;
 }
 else
 {
  if(rank[px]==rank[py])
   rank[py]++;
  p[px]=py;
  kind[px]=(3-kind[x]+d+kind[y])%3;
 }
}
int main()
{
 int i;
 int count=0;
 scanf("%d%d",&N,&K);
 make_set(N);
 for(i=1;i<=K;i++)
 {
  scanf("%d%d%d",&D,&X,&Y);
  if(X>N||Y>N)
  {
   count++;
   continue;
  }
  if(D==2&&X==Y)
  {
   count++;
   continue;
  }
  int px=find_set(X);
  int py=find_set(Y);
  if(px==py)
  {
   if(D==1&&kind[X]!=kind[Y])
    count++;
   if(D==2&&(kind[X]+3-kind[Y])%3!=1)
    count++;
  }
  else
   union_set(px,py,X,Y,D-1);
 }
 printf("%d\n",count);
 return 0;
}

Input

Output

Sample Input

AAAAABCD
THE_CAT_IN_THE_HAT
END

Sample Output

64 13 4.9
144 51 2.8

解题思路
题意：
看了第一自然段你大概往那方面去猜了。。然后怀疑自己肯定猜错了。。因为才500+AC的题。。然后继续看第二自然段。。看着看着你又往那方面想去了。。然后又怀疑自己。。继续看。。循环。。至倒数几个自然段。。于是你杯具的发现。。还是让我无情的告诉你：是的！就是你想的那样！just huffman编码！！
思路：
Huffman算法不懂的话那么有书的也该翻翻你的离散数学了，没书的就直接google之吧，就是贪心思想，这里也不说了，没事在这写什么鬼huffman算法。。（偷了个懒，用了STL中的优先队列- -）源代码如下：
源程序
#include<iostream>
#include<queue>
using namespace std;
char s[500];
int c[200];
class cmp
{
public:
 bool operator()(int x,int y)
 {
  return x>y;
 }
};
priority_queue<int,vector<int>,cmp>Q;
int main()
{
 int i,l;
 while(gets(s))
 {
  if(!strcmp(s,"END"))
   break;
  l=strlen(s);
  for(i=0;i<l;i++)
   c[s[i]]++;
  for(i=0;i<200;i++)
  {
   if(c[i])
    Q.push(c[i]),c[i]=0;
  }
  int sum=0;
  while(Q.size()>1)
  {
   int a=Q.top();Q.pop();
   int b=Q.top();Q.pop();
   sum+=a+b;
   Q.push(a+b);
  }
  if(!sum)
   sum=l;
  while(!Q.empty())
   Q.pop();
  printf("%d %d %.1f\n",8*l,sum,double(double(8*l)/sum));
 }
}

In how many ways can you tile a 2xn rectangle by 2x1 or 2x2 tiles?
Here is a sample tiling of a 2x17 rectangle.

Input

Output

Sample Input

2
8
12
100
200

Sample Output

3
171
2731
845100400152152934331135470251
1071292029505993517027974728227441735014801995855195223534251

解题思路
题意：
用2*1和2*2的格子填充2*n的格子的方案数
思路：
矩阵乘法+Java高精，详见Matrix67大牛，再次OrzMatrix67。源代码如下：
源程序
import java.math.*;
import java.util.*;
public class Main {
 public BigInteger A[][]=new BigInteger[4][4];
 public BigInteger fA[][]=new BigInteger[4][4];
 public void init(){
  int i,j;
  for(i=0;i<4;i++){
   for(j=0;j<4;j++){
    A[i][j]=new BigInteger("0");
    fA[i][j]=new BigInteger("0");
   }
  }
  fA[0][3]=A[0][3]=BigInteger.valueOf(2);
  fA[2][1]=A[2][1]=BigInteger.valueOf(1);
  fA[1][2]=A[1][2]=BigInteger.valueOf(1);
  fA[3][0]=A[3][0]=BigInteger.valueOf(1);
  fA[3][3]=A[3][3]=BigInteger.valueOf(1);
 }
 public void matrixmul(BigInteger A[][],BigInteger B[][],int n)   //n阶方阵相乘
 {
  int i,j,k;
  BigInteger C[][]=new BigInteger[4][4];
  for(i=0;i<n;i++)
  {
   for(j=0;j<n;j++)
    C[i][j]=new BigInteger("0");
  }
  for(i=0;i<n;i++)
  {
   for(j=0;j<n;j++)
   {
    for(k=0;k<n;k++)
     C[i][j]=C[i][j].add(A[i][k].multiply(B[k][j]));
   }
  }
  for(i=0;i<n;i++)
  {
   for(j=0;j<n;j++)
    A[i][j]=C[i][j];
  }
 }
 public void matrixpow(BigInteger A[][],int n,int k)  //n阶方阵的k次幂
 {
  if(k==1)
   return;
  if((k&1)==0)
  {
   matrixpow(A,n,k/2);
   matrixmul(A,A,n);
  }
  else
  {
   matrixpow(A,n,k/2);
   matrixmul(A,A,n);
   matrixmul(A,fA,n);
  }
 }
 public static void main(String args[]){
  Main t=new Main();
  t.init();
  Scanner cin=new Scanner(System.in);
  int n;
  while(cin.hasNext()){
   n=cin.nextInt();
   if(n==0){
    System.out.println(1);
    continue;
   }
   t.matrixpow(t.A,4,n);
   System.out.println(t.A[3][3]);
   t.init();
  }
 }
}

Input

Output

Sample Input

2 2 4
0 1
1 1

Sample Output

1 2
2 3

解题思路

题意：

给出n阶方阵A，输出矩阵S = A + A^2 + A^3 + … + A^k.矩阵每个数结果摸m

思路：

当k为偶数，则S=A+...+A^(k/2)+A^(k/2)(A+...+A^(k/2)).于是只需二分求出A+...+A(k/2)和A^(k/2).矩阵的幂同样可以二分，因为矩阵相乘满足结合律。

当k为奇数时，则S(k)=S(k-1)+A^k.源代码如下：

源程序

#include<iostream>
using namespace std;
int A[31][31];
int fA[31][31];
int n,k,m;
void matrixadd(int A[][31],int B[][31],int n)   //n阶方阵相加
{
 int i,j;
 for(i=1;i<=n;i++)
 {
  for(j=1;j<=n;j++)
  {
   A[i][j]+=B[i][j];
   A[i][j]%=m;
  }
 }
}
void matrixmul(int A[][31],int B[][31],int n)   //n阶方阵相乘
{
 int i,j,k;
 int C[31][31];
 for(i=1;i<=n;i++)
 {
  for(j=i;j<=n;j++)
   C[i][j]=C[j][i]=0;
 }
 for(i=1;i<=n;i++)
 {
  for(j=1;j<=n;j++)
  {
   for(k=1;k<=n;k++)
    C[i][j]+=(A[i][k]*B[k][j])%m;
  }
 }
 for(i=1;i<=n;i++)
 {
  for(j=1;j<=n;j++)
   A[i][j]=C[i][j]%m;
 }
}
void matrixpow(int A[][31],int n,int k)  //n阶方阵的k次幂
{
 if(k==1)
  return;
 if((k&1)==0)
 {
  matrixpow(A,n,k/2);
  matrixmul(A,A,n);
 }
 else
 {
  matrixpow(A,n,k/2);
  matrixmul(A,A,n);
  matrixmul(A,fA,n);
 }
}
void NARUTOACM(int A[][31],int n,int k)  //解决问题
{
 int i,j;
 if(k==1)
  return;
 if((k&1)==0)
 {
  NARUTOACM(A,n,k/2);
  int B[31][31];
  for(i=1;i<=n;i++)
  {
   for(j=1;j<=n;j++)
    B[i][j]=fA[i][j];
  }
  matrixpow(B,n,k/2);
  matrixmul(B,A,n);
  matrixadd(A,B,n);
 }
 else
 {
  NARUTOACM(A,n,k-1);
  int B[31][31];
  for(i=1;i<=n;i++)
  {
   for(j=1;j<=n;j++)
    B[i][j]=fA[i][j];
  }
  matrixpow(B,n,k);
  matrixadd(A,B,n);
 }
}
int main()
{
 int i,j;
 scanf("%d%d%d",&n,&k,&m);
 for(i=1;i<=n;i++)
 {
  for(j=1;j<=n;j++)
  {
   scanf("%d",&A[i][j]);
   fA[i][j]=A[i][j];
  }
 }
 NARUTOACM(A,n,k);
 for(i=1;i<=n;i++)
 {
  for(j=1;j<n;j++)
   printf("%d ",A[i][j]);
  printf("%d\n",A[i][j]);
 }
 return 0;
} 

Squares and rectangles fascinated the famous Dutch painter Piet Mondriaan. One night, after producing the drawings in his 'toilet series' (where he had to use his toilet paper to draw on, for all of his paper was filled with squares and rectangles), he dreamt of filling a large rectangle with small rectangles of width 2 and height 1 in varying ways.

Expert as he was in this material, he saw at a glance that he'll need a computer to calculate the number of ways to fill the large rectangle whose dimensions were integer values, as well. Help him, so that his dream won't turn into a nightmare!

Input

Output

For each test case, output the number of different ways the given rectangle can be filled with small rectangles of size 2 times 1. Assume the given large rectangle is oriented, i.e. count symmetrical tilings multiple times.

Sample Input

1 2
1 3
1 4
2 2
2 3
2 4
2 11
4 11
0 0

Sample Output

1
0
1
2
3
5
144
51205

解题思路
题意：
有1*2和2*1的小矩形，让你填充给定长宽的大矩形，求有多少种填充方法。
思路：
名字的话貌似叫做状态压缩DP吧。0表示该格子为向右横排，或者向上竖排，1表示该格子为向下竖排，上小到大一行一行考察，以f(i,j)表示在第i行状态为j时的总数，于是f(h,0)即为所求。即最后一排状态全为0，因为有1的话就会对下一排产生影响。所以一行中满足要求的就有1、00序列，不满足要求的有10，因为单个格子无法用小矩形填充。
则有方程f(i,j)=sigamaf(i-1,k)，j，k是满足能够排好的状态。源代码如下：
源程序
#include<iostream>
using namespace std;
const int maxstatus=1<<11;
__int64 f[12][maxstatus];
bool check(int nstatus)   //此处传入的为逆状态（0<——>1互换）,很有好处滴。。
{
 while(1)
 {
  if((nstatus&1)==0)
   nstatus>>=1;
  else if((nstatus&1)==1&&(nstatus&2)==0)
   return false;
  else
   nstatus>>=2;
  if(nstatus==0)
   return true;
 }
}
void init(int w)
{
 int i;
 int status=(1<<w)-1;
 for(i=0;i<=status;i++)
 {
  if(check(status-i))
   f[1][i]=1;
  else
   f[1][i]=0;
 }
}
__int64 dp(int h,int w)
{
 if((h&1)==1&&(w&1)==1)
  return 0;
 init(w);
 int i,j,k;
 int status=(1<<w)-1;
 for(i=2;i<=h;i++)
 {
  for(j=0;j<=status;j++)   //该行的状态
  {
   f[i][j]=0;
   for(k=0;k<=status;k++)   //上一行的状态
   {
    if(f[i-1][k]&&!(j&k)&&check(status-(j|k)))  //j|k为了说明该行某位置为0且上一行为1的状态，该情况0不表示横排，而表示向上竖排
     f[i][j]+=f[i-1][k]; 
   } 
  }
 }
 return f[h][0];
}
int main()
{
 int h,w;
 while(scanf("%d%d",&h,&w)&&(h+w))
 {
  if(h<w)
   h^=w^=h^=w;
  printf("%I64d\n",dp(h,w));
 }
}

Nemo is a naughty boy. One day he went into the deep sea all by himself. Unfortunately, he became lost and couldn't find his way home. Therefore, he sent a signal to his father, Marlin, to ask for help.
After checking the map, Marlin found that the sea is like a labyrinth with walls and doors. All the walls are parallel to the X-axis or to the Y-axis. The thickness of the walls are assumed to be zero.
All the doors are opened on the walls and have a length of 1. Marlin cannot go through a wall unless there is a door on the wall. Because going through a door is dangerous (there may be some virulent medusas near the doors), Marlin wants to go through as few doors as he could to find Nemo.
Figure-1 shows an example of the labyrinth and the path Marlin went through to find Nemo.

We assume Marlin's initial position is at (0, 0). Given the position of Nemo and the configuration of walls and doors, please write a program to calculate the minimum number of doors Marlin has to go through in order to reach Nemo.

Input

Output

Sample Input

8 9
1 1 1 3
2 1 1 3
3 1 1 3
4 1 1 3
1 1 0 3
1 2 0 3
1 3 0 3
1 4 0 3
2 1 1
2 2 1
2 3 1
3 1 1
3 2 1
3 3 1
1 2 0
3 3 0
4 3 1
1.5 1.5
4 0
1 1 0 1
1 1 1 1
2 1 1 1
1 2 0 1
1.5 1.7
-1 -1

Sample Output

5
-1

 
解题思路
题意：
Marlin的儿子Nemo迷路了，他发信号向他爸爸求救，于是Marlin就得到了地图，要你设计一条道路去救他儿子。要求你穿过最少的门，因为穿过门时会有危险。Marlin的初始位置在(0,0)这个坐标。
思路：
这个题一看就是搜索，但是如何的搜就是问题了。一开始我也想了蛮久，后来想到把每一个格子点化，还要记录格子的四条边的情况，是通还是不通，于是Nemo所在地也处于一点了。然后直接bfs稍微加点剪枝就好了。这里注意：可通的情况有两种，一种是有门，这时穿过的门数就要加1.另一种是既没有墙也没有门，这也是可通的，这种情况就不要加1了。一开始我都没有注意到，然后经过MasterLuo大牛指点了下才发现这个问题，于是接下来就是去搜了。源代码如下：
源程序
#include<iostream>
#include<queue>
using namespace std;
queue< pair<int,int> >Q;
const int INF=1<<20;
struct grid    //记录小格子的四条边,1代表不能通过，0代表能有门通过，-1代表通过
{
 int l;
 int r;
 int t;
 int b;
};
grid map[1<<8][1<<8];  //以一个格子的左下角的坐标代表该格子
int M,N;
int X,Y; //nemo的格子的坐标
int x1,y1,x2,y2; //记录map的左下角的坐标和右上角的坐标；
int visit[1<<8][1<<8];
int step[1<<8][1<<8];
int ans=INF;
void BFS()
{
 memset(step,0,sizeof(step));
 memset(visit,0,sizeof(visit));
 int flag=0;
 int nowx,nowy;
 while(!Q.empty())
  Q.pop();
 if(X>=x2||X<x1||Y>=y2||Y<y1)
 {
  printf("0\n");
  return;
 }
 Q.push(make_pair(X,Y));
 while(!Q.empty())
 {
  nowx=Q.front().first;nowy=Q.front().second;Q.pop();
  if(nowx>=x2||nowx<x1||nowy>=y2||nowy<y1)
  {
   if(ans>step[nowx][nowy])
    ans=step[nowx][nowy];
   flag=1;
   continue;
  }
  if(map[nowx][nowy].t!=1)
  { 
   if(nowx>=x2||nowx<x1||nowy>=y2||nowy<y1)
   {
    flag=1;
    if(ans>step[nowx][nowy])
     ans=step[nowx][nowy];
   }
   else
   {
    if(!visit[nowx][nowy+1])
    {
     if(map[nowx][nowy].t==0)
      step[nowx][nowy+1]=step[nowx][nowy]+1;
     else
      step[nowx][nowy+1]=step[nowx][nowy];
     visit[nowx][nowy+1]=1,Q.push(make_pair(nowx,nowy+1));
    }
   }
  }
  if(map[nowx][nowy].b!=1)
  {
   if(nowx>=x2||nowx<x1||nowy>=y2||nowy<y1)
   {
    flag=1;
    if(ans>step[nowx][nowy])
     ans=step[nowx][nowy];
   }
   else
   {
    if(!visit[nowx][nowy-1])
    {
     if(map[nowx][nowy].b==0)
      step[nowx][nowy-1]=step[nowx][nowy]+1;
     else
      step[nowx][nowy-1]=step[nowx][nowy];
     visit[nowx][nowy-1]=1,Q.push(make_pair(nowx,nowy-1));
    }
   }
  }
  if(map[nowx][nowy].l!=1)
  {
   if(nowx>=x2||nowx<x1||nowy>=y2||nowy<y1)
   {
    flag=1;
    if(ans>step[nowx][nowy])
     ans=step[nowx][nowy];
   }
   else
   {
    if(!visit[nowx-1][nowy])
    {
     if(map[nowx][nowy].l==0)
      step[nowx-1][nowy]=step[nowx][nowy]+1;
     else
      step[nowx-1][nowy]=step[nowx][nowy];
     visit[nowx-1][nowy]=1,Q.push(make_pair(nowx-1,nowy));
    }
   }
  }
  if(map[nowx][nowy].r!=1)
  {
   if(nowx>=x2||nowx<x1||nowy>=y2||nowy<y1)
   {
    flag=1;
    if(ans>step[nowx][nowy])
     ans=step[nowx][nowy];
   }
   else
   {
    if(!visit[nowx+1][nowy])
    {
     if(map[nowx][nowy].r==0)
      step[nowx+1][nowy]=step[nowx][nowy]+1;
     else
      step[nowx+1][nowy]=step[nowx][nowy];
     visit[nowx+1][nowy]=1,Q.push(make_pair(nowx+1,nowy));
    }
   }
  }
 }
 if(flag)
  printf("%d\n",ans);
 else
  printf("-1\n");
}
int main()
{
 int i,j;
 int x,y,d,t;
 double f1,f2;
 while(scanf("%d%d",&M,&N))
 {
  if(M==-1&&N==-1)
   break;
  ans=INF;
  for(i=0;i<256;i++)
  {
   for(j=i;j<256;j++)
    map[i][j].b=map[i][j].l=map[i][j].r=map[i][j].t=map[j][i].b=map[j][i].l=map[j][i].r=map[j][i].t=-1;
  }
  x1=y1=INF;x2=y2=-INF;
  for(i=1;i<=M;i++)
  {
   scanf("%d%d%d%d",&x,&y,&d,&t);
   if(x2<x)
    x2=x;
   if(y2<y)
    y2=y;
   if(x1>x)
    x1=x;
   if(y1>y)
    y1=y;
   int mx=x+t,my=y+t;
   if(d==0)
   {
    for(x;x<mx;x++)
     map[x][y-1].t=map[x][y].b=1;
   }
   else
   {
    for(y;y<my;y++)
     map[x-1][y].r=map[x][y].l=1;
   }
  }
  for(i=1;i<=N;i++)
  {
   scanf("%d%d%d",&x,&y,&d);
   if(d==0)
    map[x][y-1].t=map[x][y].b=0;
   else
    map[x-1][y].r=map[x][y].l=0;
  }
  scanf("%lf%lf",&f1,&f2);
  if(f1>=x2||f1<x1||f2>=y2||f2<y1)
  {
   printf("0\n");
   continue;
  }
  X=int(f1);Y=int(f2);
  BFS();
 }
 return 0;
}

It is well known that a human gene can be considered as a sequence, consisting of four nucleotides, which are simply denoted by four letters, A, C, G, and T. Biologists have been interested in identifying human genes and determining their functions, because these can be used to diagnose human diseases and to design new drugs for them.

A human gene can be identified through a series of time-consuming biological experiments, often with the help of computer programs. Once a sequence of a gene is obtained, the next job is to determine its function.
One of the methods for biologists to use in determining the function of a new gene sequence that they have just identified is to search a database with the new gene as a query. The database to be searched stores many gene sequences and their functions – many researchers have been submitting their genes and functions to the database and the database is freely accessible through the Internet.

A database search will return a list of gene sequences from the database that are similar to the query gene.
Biologists assume that sequence similarity often implies functional similarity. So, the function of the new gene might be one of the functions that the genes from the list have. To exactly determine which one is the right one another series of biological experiments will be needed.

Your job is to make a program that compares two genes and determines their similarity as explained below. Your program may be used as a part of the database search if you can provide an efficient one.
Given two genes AGTGATG and GTTAG, how similar are they? One of the methods to measure the similarity
of two genes is called alignment. In an alignment, spaces are inserted, if necessary, in appropriate positions of
the genes to make them equally long and score the resulting genes according to a scoring matrix.

For example, one space is inserted into AGTGATG to result in AGTGAT-G, and three spaces are inserted into GTTAG to result in –GT--TAG. A space is denoted by a minus sign (-). The two genes are now of equal
length. These two strings are aligned:

AGTGAT-G
-GT--TAG

In this alignment, there are four matches, namely, G in the second position, T in the third, T in the sixth, and G in the eighth. Each pair of aligned characters is assigned a score according to the following scoring matrix.

denotes that a space-space match is not allowed. The score of the alignment above is (-3)+5+5+(-2)+(-3)+5+(-3)+5=9.

Of course, many other alignments are possible. One is shown below (a different number of spaces are inserted into different positions):

AGTGATG
-GTTA-G

This alignment gives a score of (-3)+5+5+(-2)+5+(-1) +5=14. So, this one is better than the previous one. As a matter of fact, this one is optimal since no other alignment can have a higher score. So, it is said that the
similarity of the two genes is 14.

Input

Output

Sample Input

2
7 AGTGATG
5 GTTAG
7 AGCTATT
9 AGCTTTAAA 

Sample Output

14
21

 
解题思路
题意：
给两串DNA序列，按照给定的方法找他们最大的相似度。比如序列AGTGATG和GTTAG，化为AGTGATG和-GTTA-G，相似度最大，为14。
思路：
由低到高的往上递推，动态规划。
设d(i,j)为第一个序列(s1)的前i个数和第二个序列(s2)的前j个数的相似度的最大值。当s1[i+1]==s2[j+1]时，由题目给出的表显然可以得出d(i+1,j+1)=d(i,j)+p[s1[i+1]][s2[j+1]];p数组为题目中给出的那个表格。当s1[i+1]!=s2[j+1]时，反证法显然有d(i+1,j+1)=
max(d(i,j)+p[s1[i+1]][s2[j+1]],d(i,j+1)+p[s1[i+1]][‘-‘],d(i+1,j)+p[‘-‘][s2[j+1]])。于是，两个for就解决问题了。最后注意初始化d数组，当i=0时相当于s1序列全都是用’-‘来比较，同样j=0相当于s2序列全都用’-‘来比较(这样说好像有点不太严谨，反正知道意思就行了)。当i==0&&j==0时，显然d(0,0)为0。下面是源代码：哦。。还有。。由于题目说’-‘和’-‘比较无意义，故把p['-']['-']初始为负无穷大。
源程序
#include<iostream>
using namespace std;
const int INF=1<<20;
char s1[200];
int len1;
char s2[200];
int len2;
int p[200][200];
int d[200][200];
void init()
{
 p['A']['A']=5;
 p['C']['C']=5;
 p['G']['G']=5;
 p['T']['T']=5;
 p['A']['C']=p['C']['A']=-1;
 p['A']['G']=p['G']['A']=-2;
 p['A']['T']=p['T']['A']=-1;
 p['A']['-']=p['-']['A']=-3;
 p['C']['G']=p['G']['C']=-3;
 p['C']['T']=p['T']['C']=-2;
 p['C']['-']=p['-']['C']=-4;
 p['G']['T']=p['T']['G']=-2;
 p['G']['-']=p['-']['G']=-2;
 p['T']['-']=p['-']['T']=-1;
 p['-']['-']=-INF;
}
int main()
{
 init();
 int t,i,j;
 scanf("%d",&t);
 s1[0]=s2[0]='-';
 while(t--)
 {
  memset(d,0,sizeof(d));
  scanf("%d",&len1);
  for(i=1;i<=len1;i++)
   scanf(" %c",&s1[i]);
  scanf("%d",&len2);
  for(i=1;i<=len2;i++)
   scanf(" %c",&s2[i]);
  for(i=1;i<=len2;i++)
   d[0][i]=d[0][i-1]+p['-'][s2[i]];
  for(i=1;i<=len1;i++)
   d[i][0]=d[i-1][0]+p[s1[i]]['-'];
  for(i=1;i<=len1;i++)
  {
   for(j=1;j<=len2;j++)
   {
    int ans=-INF;
    if(s1[i]!=s2[j])
    {
     if(d[i][j-1]+p['-'][s2[j]]>ans)
      ans=d[i][j-1]+p['-'][s2[j]];
     if(d[i-1][j]+p[s1[i]]['-']>ans)
      ans=d[i-1][j]+p[s1[i]]['-'];
     if(d[i-1][j-1]+p[s1[i]][s2[j]]>ans)
      ans=d[i-1][j-1]+p[s1[i]][s2[j]];
    }
    else
     ans=d[i-1][j-1]+p[s1[i]][s2[j]];
    d[i][j]=ans;
   }
  }
  printf("%d\n",d[len1][len2]);
 }
 return 0;
}

Flip game is played on a rectangular 4x4 field with two-sided pieces placed on each of its 16 squares. One side of each piece is white and the other one is black and each piece is lying either it's black or white side up. Each round you flip 3 to 5 pieces, thus changing the color of their upper side from black to white and vice versa. The pieces to be flipped are chosen every round according to the following rules:

1. Choose any one of the 16 pieces.
   
2. Flip the chosen piece and also all adjacent pieces to the left, to the right, to the top, and to the bottom of the chosen piece (if there are any).

Consider the following position as an example:

bwbw
wwww
bbwb
bwwb
Here "b" denotes pieces lying their black side up and "w" denotes pieces lying their white side up. If we choose to flip the 1st piece from the 3rd row (this choice is shown at the picture), then the field will become:

bwbw
bwww
wwwb
wwwb
The goal of the game is to flip either all pieces white side up or all pieces black side up. You are to write a program that will search for the minimum number of rounds needed to achieve this goal.

Input

Output

Sample Input

bwwb
bbwb
bwwb
bwww

Sample Output

4

 
解题思路
题意：
一个棋盘，有黑白两种棋子。你可以翻动任一颗棋子，但是翻动有个规则，那就是该棋子周围的棋子都要跟着翻转，所谓翻转就是白变黑或黑变白。让你求出至少要翻转的次数使得棋盘达到一种状态，该状态就是棋盘中所有棋子都是同一种颜色。
思路：
此题我用的方法是状态压缩bfs，令白棋的状态为0，黑棋状态为1，显然要达到所要求的状态就只有两种情况：0000000000000000（2）=0（10）；1111111111111111（2）=65535（10）；因为有16个棋子，每个棋子一个状态，刚好可以用一个int型。此题我用此方法优化到16ms的极限了，不晓得还能如何优化，希望大牛帮忙看看。貌似此题还可以枚举做，这样做貌似很快，一般0ms，但我不晓得如何枚举，希望有大牛指点指点。源代码如下：
源程序
#include<iostream>
using namespace std;
struct node
{
 int s;
 int c;
};
class Queue
{
public:
 node n[1<<17];
 int front;
 int rear;
 static const int f=(1<<17)-1;
 Queue()
 {
  front=rear=0;
 }
 void push(node x)
 {
  n[rear].s=x.s;
  n[rear].c=x.c;
  rear++;
  rear&=f;
 }
 void pop(node &x)
 {
  x.s=n[front].s;
  x.c=n[front].c;
  front++;
  front&=f;
 }
};
Queue q;
int p[5][5];
int flag[1<<17];
void inline init()
{
 int i,j;
 for(i=1;i<=4;i++)
 {
  for(j=1;j<=4;j++)
   p[i][j]=1<<(20-4*i-j);
 }
}
int main()
{
 init();
 int s=0;
 char a;
 int i,j;
 for(i=1;i<=4;i++)
 {
  for(j=1;j<=4;j++)
  {
   s=s<<1;
   scanf("%c",&a);
   if(a=='b')
    s=s^1;
  }
  getchar();
 }
 node n,t;
 n.s=s;
 n.c=0;
 q.push(n);
 int f=0;
 while(q.front!=q.rear)
 {
  q.pop(n);
  if(n.s==0||n.s==65535)
  {
   f=1;
   break;
  }
  for(i=1;i<=4;i++)
  {
   for(j=1;j<=4;j++)
   {
    int e=n.s;
    e^=p[i][j];
    if(i-1>0)
     e^=p[i-1][j];
    if(i+1<5)
     e^=p[i+1][j];
    if(j-1>0)
     e^=p[i][j-1];
    if(j+1<5)
     e^=p[i][j+1];
    t.s=e;
    t.c=n.c+1;
    if(!flag[e])
    {
     q.push(t);
     flag[e]=1;
    }
    if(t.s==0||t.s==65535)
    {
     n.s=t.s;
     n.c=t.c;
     f=1;
     break;
    }
   }
  }
  if(f==1)
   break;
 }
 if(f==1)
  printf("%d\n",n.c);
 else
  printf("Impossible\n");
 return 0;
}

Input

Output

Sample Input

2
3
1

Sample Output

Scenario #1:
5
Scenario #2:
2

 
解题思路
题意：
找出n位0或1的组成的排列的总数，其中不能出现连续的1.比如n=3.那么有这么几种排列：000 001 010 100 101.如果这样：011 110 111就不行，因为出现了连续的1.
思路：
如果一种情况一种情况的搜的话，那么n比较大时，2^n种情况显然会TLE。这里，我们可以发现如下规律：
1.      总数=以0为尾的总数+以1为尾的总数。（这显然，无需证明）
2.      设p0[i]为i位时以0结尾的总数，p1[i]为i位时以1结尾的总数。那么：p0[i+1]=p0[i]+p1[i];p1[i+1]=p0[i];   证明：i位时，我们可以在那些数的基础上往后添加0或1.当添0时，所有的数都可以，即得到了i+1位时以0为尾的总数。当添加1时，因为不能出现连续1，所以只能在i位的以0结尾的数的后面加1.
3.      p0[1]=1;p1[1]=1;（显然）
于是这题就变成水了。。源代码如下：
源程序
#include<iostream>
using namespace std;
int p1[46];
int p0[46];
int main()
{
 int i;
 p1[1]=1;p0[1]=1;
 for(i=2;i<=45;i++)
 {
  p1[i]=p0[i-1];
  p0[i]=p0[i-1]+p1[i-1];
 }
 int n,t,c=0;
 scanf("%d",&t);
 while(t--)
 {
  c++;
  scanf("%d",&n);
  printf("Scenario #%d:\n%d\n\n",c,p1[n]+p0[n]);
 }
 return 0;
}

7
3   8
8   1   0
2   7   4   4
4   5   2   6   5

(Figure 1)

Input

Output

Sample Input

5
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5

Sample Output

30

 
解题思路
题意：
一三角形，从头找一条线路一直到最底层，让这条路上的数的和最大。并且每步只能往下一层的左斜对角或右斜对角走。
思路：
显然的dp之。。。。我分别写了从上往下和从下往上dp。感觉从下往上容易多了。下面是源代码：
源程序
从上往下：
#include<iostream>
using namespace std;
int p[101][101];
int m[101][101]; //记录从第一层到第i层第j个数能达到的最大值
int MAX[101];  //记录从第一层到第i层能达到的最大值
int main()
{
 int N,i,j;
 cin>>N;
 for(i=1;i<=N;i++)
 {
  for(j=1;j<=i;j++)
   cin>>p[i][j];
 }
 for(i=1;i<=N;i++)
 {
  for(j=1;j<=i;j++)
  {
   if(j==1)  //在这层的第一个时，显然只有上层第一个才能选这条路
    m[i][j]=m[i-1][j]+p[i][j];
   else if(j==i)  //同第一个的情况
    m[i][j]=m[i-1][j-1]+p[i][j];
   else  //在中间时，上一层就可以有两种选择了
   {
    if(m[i-1][j-1]+p[i][j]>m[i-1][j]+p[i][j])
     m[i][j]=m[i-1][j-1]+p[i][j];
    else
     m[i][j]=m[i-1][j]+p[i][j];
   }
   if(m[i][j]>MAX[i])
    MAX[i]=m[i][j];
  }
 }
 cout<<MAX[N]<<endl;
 return 0;
}
从下往上：
#include<iostream>
using namespace std;
int p[105][105];
int m[105][105]; //记录从第i层到最后一层所能达到的最大值
int main()
{
 int i,j;
 int n;
 scanf("%d",&n);
 for(i=1;i<=n;i++)
 {
  for(j=1;j<=i;j++)
   scanf("%d",&p[i][j]);
 }
 for(i=n;i>=1;i--)
 {
  for(j=1;j<=i;j++)
   m[i][j]=m[i+1][j]>m[i+1][j+1]?m[i+1][j]+p[i][j]:m[i+1][j+1]+p[i][j]; //每个都有两种选择
 }
 printf("%d\n",m[1][1]);
 return 0;
}

Input

Output

Sample Input

2
8 8
########
#......#
#.####.#
#.####.#
#.####.#
#.####.#
#...#..#
#S#E####
9 5
#########
#.#.#.#.#
S.......E
#.#.#.#.#
#########

Sample Output

37 5 5
17 17 9

 
解题思路
题意：
题目意思是给你一个迷宫，有起点和终点，让你分别求出往左搜和往右搜需走的距离和所到达终点能走的最短距离。
思路：
思路就是搜索，求最短用bfs，四个方向一起搜，应该比深搜要快些。求往左和往右就用dfs，注意设置目前方向，相当于模拟往左的过程。源代码如下：
源程序
#include<iostream>
#include<queue>
using namespace std;
int step[4][2]={{-1,0},{0,-1},{1,0},{0,1}};

int W,H;
int sx,sy;
char g[50][50];
int toward;
int find(char *a,char x)
{
 int i;
 int len=strlen(a);
 for(i=0;i<len;i++)
 {
  if(a[i]==x)
   return i;
 }
 return -1;
}
int BFS(int sx,int sy)
{
 int i;
 int cnt[50][50];
 memset(cnt,0,sizeof(cnt));
 queue< pair<int,int> >q;
 pair<int,int>p=make_pair(sx,sy);
 cnt[sx][sy]=1;
 q.push(p);
 while(!q.empty())
 {
  p=q.front();q.pop();
  if(g[p.first][p.second]=='E')
   return cnt[p.first][p.second];
  for(i=0;i<4;i++)
  {
   int x1=p.first+step[i][0];
   int y1=p.second+step[i][1];
   if(x1>=0&&x1<H&&y1>=0&&y1<W&&g[x1][y1]!='#'&&!cnt[x1][y1])
   {
    cnt[x1][y1]=cnt[p.first][p.second]+1;
    q.push(make_pair(x1,y1));
   }
  }
 }
 return 0;
}
int DFS(int sx,int sy,int toward,char mark)
{
 int i;
 if(g[sx][sy]=='E')
  return 1;
 if(mark=='l')
 {
  for(i=toward+1;i>=toward-2;i--)
  {
   int t=(8+i)&3;
   int x1=sx+step[t][0];
   int y1=sy+step[t][1];
   if(x1<H&&x1>=0&&y1>=0&&y1<W&&g[x1][y1]!='#')
    return 1+DFS(x1,y1,t,mark);
  }
 }
 else if(mark=='r')
 {
  for(i=toward-1;i<=toward+2;i++)
  {
   int t=(8+i)&3;
   int x1=sx+step[t][0];
   int y1=sy+step[t][1];
   if(x1<H&&x1>=0&&y1>=0&&y1<W&&g[x1][y1]!='#')
    return 1+DFS(x1,y1,t,mark);
  }
 }
}
int main()
{
 int t,i;
 scanf("%d",&t);
 while(t--)
 {
  scanf("%d%d\n",&W,&H);
  for(i=0;i<H;i++)
   gets(g[i]);
  for(i=0;i<H;i++)
  {
   if((sy=find(g[i],'S'))!=-1)
   {
    sx=i;
    break;
   }
  }
  if(sx==0)
   toward=2;
  else if(sx==H-1)
   toward=0;
  else if(sy==0)
   toward=3;
  else if(sy==W-1)
   toward=1;
  printf("%d %d %d\n",DFS(sx,sy,toward,'l'),DFS(sx,sy,toward,'r'),BFS(sx,sy));
 }
 return 0;
}

Input

Output

Sample Input

3
cat tree tcraete
cat tree catrtee
cat tree cttaree

Sample Output

Data set 1: yes
Data set 2: yes
Data set 3: no

 
解题思路
题意：
看两个字符串能不能组成第三个字符串，而且字符串中的字符顺序保持不变。
思路：
本题是几个朋友聊着就随便发现的一道题，开始朋友说是用dp，想了下没思路，就人肉之。开始写了个void型的搜索，结果一直WA，后来把他改为bool型的搜索，就过了。。。神奇。思路。。。就人肉无所谓思路。。就直接发代码吧。。
现把两份代码，一份WA的，一份A的都发下，希望大牛能指出我WA代码的错误。源代码如下：
源程序
AC代码：
#include<iostream>
using namespace std;
char a[300],b[300],c[600];
int lena,lenb,lenc;
bool search(int pa,int pb,int pc)
{
 if(pa==lena)
 {
  for(pb;pb<lenb;pb++)
  {
   if(b[pb]!=c[pc++])
    return false;
  }
  return true;
 }
 if(pb==lenb)
 {
  for(pa;pa<lena;pa++)
  {
   if(a[pa]!=c[pc++])
    return false;
  }
  return true;
 }
 if(c[pc]!=a[pa]&&c[pc]!=b[pb])
  return false;
 if(c[pc]==a[pa])
 {
  if(search(pa+1,pb,pc+1))
   return true;
  else
  {
   if(c[pc]=b[pb])
    return search(pa,pb+1,pc+1);
   return false;
  }
 }
 if(c[pc]=b[pb])
 {
  if(search(pa,pb+1,pc+1))
   return true;
  else
  {
   if(c[pc]==a[pa])
    return search(pa+1,pb,pc+1);
   return false;
  }
 }
}
int main()
{
 int T,test=0;
 int pa,pb,pc;
 scanf("%d",&T);
 getchar();
 while(T--)
 {
  test++;
  pa=pb=pc=0;
  scanf("%s%s%s",a,b,c);
  lena=strlen(a);
  lenb=strlen(b);
  lenc=strlen(c);
  if((lena+lenb!=lenc)||(c[lenc-1]!=a[lena-1]&&c[lenc-1]!=b[lenb-1]))
  {
   printf("Data set %d: no\n",test);
   continue;
  }
  if(!search(pa,pb,pc))
   printf("Data set %d: no\n",test);
  else
   printf("Data set %d: yes\n",test);
 }
 return 0;
}

 
WA代码：（由于改了多次，写的好乱。。）
#include<iostream>
using namespace std;
char a[300],b[300],c[600];
int lena,lenb,lenc;
bool ok=false;
bool iok=false;
void search(int pa,int pb,int pc)
{
    if(iok)
          return;
    if(ok)
          return;
    if(pa==lena)
    {
          for(pb;pb<lenb;pb++)
          {
                if(b[pb]!=c[pc++])
                      break;
          }
          if(pb==lenb)
                ok=true;
          return;
    }
    if(pb==lenb)
    {
          for(pa;pa<lena;pa++)
          {
                if(a[pa]!=c[pc++])
                      break;
          }
          if(pa==lena)
                ok=true;
          return;
    }
    if(c[pc]!=a[pa]&&c[pc]!=b[pb])
    {
          iok=true;
          return;
    }
    if(iok)
          return;
    if(c[pc]==a[pa])
          search(pa+1,pb,pc+1);
    if(ok)
          return;
    if(c[pc]=b[pb])
          search(pa,pb+1,pc+1);
    if(ok)
          return;
    if(iok)
          return;
}
int main()
{
    int T,test=0;
    int pa,pb,pc;
    scanf("%d",&T);
    getchar();
    while(T--)
    {
          iok=ok=false;
          test++;
          pa=pb=pc=0;
          scanf("%s%s%s",a,b,c);
          lena=strlen(a);
          lenb=strlen(b);
          lenc=strlen(c);
        if(lena+lenb!=lenc||(c[lenc-1]!=a[lena-1]&&c[lenc-1]!=b[lenb-1]))
          {
                printf("Data set %d: no\n",test);
                continue;
          }
          search(pa,pb,pc);
          if(!ok)
                printf("Data set %d: no\n",test);
          else
                printf("Data set %d: yes\n",test);
    }
    return 0;
}

Input

Output

Sample Input

2 12

Sample Output

6

 
解题思路
题意：
让你找两个数之间有多少个round number。round number的定义是：把一个数化成2进制，如果0的个数>=1的个数。那么该数为round number。
思路：
计算出从1到finish之间有多少个round number，再算出从1到start-1之间有多少个round number。两者相减即为两者之间的数。之所以时算出从1到start-1，时因为如果start本身时一个round number，那么最后结果就会少1. 计算的方法时先计算出2进制中每位都是1的数，这个很好计算，排列组合问题。麻烦的是计算该数从该数位数中最小的数到该数之间的round number。设howmany(n,k)为2进制为n位需要有k个0时的round number数。B数组记录该数的2进制的每一位。那么有递归公式：howmany(n,k)=howmany(n-1,k-1)(if B[n-1]==0).howmany(n,k)=C(n-2,k-1)+howmany(n-1,k).(if B[n-1]==1,C函数为组合)。
源程序
#include<iostream>
using namespace std;
int C[33][33];
int MAX[33]; 
int B[33];
int tobinary(int b)
{
 int i=1;
 while(b)
 {
  B[i++]=b%2;
  b/=2;
 }
 return i-1;
}
void init()
{
 int i,j;
 C[1][0]=C[1][1]=1;
 for(i=2;i<=32;i++)
 {
  C[i][0]=1;
  for(j=1;j<=i;j++)
   C[i][j]=C[i-1][j]+C[i-1][j-1];
 }
 MAX[1]=0;
 for(i=2;i<=32;i++)
 {
  for(j=(i+1)/2;j<i;j++)
   MAX[i]+=C[i-1][j];
 }
}
int howmany(int n,int k,int *p) 
{
 if(k>=n||k<0)
  return 0;
 if((n==1&&k==0)||(n==2&&k==1))
  return 1;
 if(p[n-1]==0)
  return howmany(n-1,k-1,p);
 else
  return C[n-2][k-1]+howmany(n-1,k,p);
}
int compute(int n)
{
 int i,ans=0;
 int len=tobinary(n);
 for(i=(len+1)/2;i<len;i++)
  ans+=howmany(len,i,B);
 for(i=1;i<len;i++)
  ans+=MAX[i];
 return ans;
}
int main()
{
 init();
 int start,finish;
 scanf("%d%d",&start,&finish);
 printf("%d\n",compute(finish)-compute(start-1));
 return 0;
}

In a country, great walls have been built in such a way that every great wall connects exactly two towns. The great walls do not cross each other. Thus, the country is divided into such regions that to move from one region to another, it is necessary to go through a town or cross a great wall. For any two towns A and B, there is at most one great wall with one end in A and the other in B, and further, it is possible to go from A to B by always walking in a town or along a great wall. The input format implies additional restrictions.

There is a club whose members live in the towns. In each town, there is only one member or there are no members at all. The members want to meet in one of the regions (outside of any town). The members travel riding their bicycles. They do not want to enter any towns, because of the traffic, and they want to cross as few great walls as possible, as it is a lot of trouble. To go to the meeting region, each member needs to cross a number (possibly 0) of great walls. They want to find such an optimal region that the sum of these numbers (crossing-sum, for short) is minimized.

The towns are labeled with integers from 1 to N, where N is the number of towns. In Figure 1, the labeled nodes represent the towns and the lines connecting the nodes represent the great walls. Suppose that there are three members, who live in towns 3, 6, and 9. Then, an optimal meeting region and respective routes for members are shown in Figure 2. The crossing-sum is 2: the member from town 9 has to cross the great wall between towns 2 and 4, and the member from town 6 has to cross the great wall between towns 4 and 7.

You are to write a program which, given the towns, the regions, and the club member home towns, computes the optimal region(s) and the minimal crossing-sum.

Input

Output

Sample Input

10
10
3
3 6 9
3
1 2 3
3
1 3 7
4
2 4 7 3
3
4 6 7
3
4 8 6
3
6 8 7
3
4 5 8
4
7 8 10 9
3
5 10 8
7
7 9 10 5 4 2 1

Sample Output

2

 
解题思路
题意：
题目意思是说有有几个人想去一个区域聚会，他们都住在某个城镇中，区域有长城围着的部分构成，外面也算一个区域。每
个点代表一个城镇，在每个城镇至多有一个人。聚会要求成员们不能进入别的城镇，只能跨过长城。让你选一个区域，使得
所有聚会成员所跨过的长城总数最少。
思路：
把区域结点化。相邻的区域之间的权值为1，否则为∞。在用floyd求出各个区域之间的最短路径。再枚举每个区域，选最少
的。其中判断是否相邻我用的是笨办法，看看我的程序就知道了。哪位大牛有更好的方法希望传授下。源代码如下：
源程序
#include<iostream>
using namespace std;
const int MAXN=260;
const int INF=1000000000;
struct region
{
 int v;
 region *next;
}* reg[MAXN];
int M,N,L;
int club[31];
int dist[MAXN][MAXN];
void add(int i,int v,region *p[])
{
 region *q=new region[1];
 q->v=v;
 q->next=p[i];
 p[i]=q;
}
bool islink(region *p,region *q)
{
 int a[MAXN],aa=0,i,j,b[MAXN],bb=0;
 for(p;p;p=p->next)
  a[aa++]=p->v;
 a[aa]=a[0];
 for(q;q;q=q->next)
  b[bb++]=q->v;
 b[bb]=b[0];
 for(i=0;i<aa;i++)
 {
  for(j=0;j<bb;j++)
  {
   if((a[i]==b[j]&&a[i+1]==b[j+1])||(a[i]==b[j+1]&&a[i+1]==b[j]))
    return true;
  }
 }
 return false;
}
bool iscontain(int v,region *p)
{
 for(p;p;p=p->next)
 {
  if(p->v==v)
   return true;
 }
 return false;
}
int main()
{
 int i,j,k,num,town;
 scanf("%d%d%d",&M,&N,&L);
 for(i=1;i<=L;i++)
  scanf("%d",club+i);
 for(i=1;i<=M;i++)
 {
  scanf("%d",&num);
  for(j=1;j<=num;j++)
  {
   scanf("%d",&town);
   add(i,town,reg);
  }
 }
 for(i=1;i<=M;i++)
 {
  for(j=i;j<=M;j++)
  {
   if(islink(reg[i],reg[j]))
    dist[i][j]=dist[j][i]=1;
   else
    dist[i][j]=dist[j][i]=INF;
  }
  dist[i][i]=0;
 }
 for(k=1;k<=M;k++)
 {
  for(i=1;i<=M;i++)
  {
   for(j=1;j<=M;j++)
   {
    if(dist[i][j]>dist[i][k]+dist[k][j])
     dist[i][j]=dist[i][k]+dist[k][j];
   }
  }
 }
 int MIN=INF,sum,mmin;
 for(i=1;i<=M;i++)
 {
  sum=0;
  for(j=1;j<=L;j++)
  {
   mmin=INF;
   for(k=1;k<=M;k++)
   {
    if(iscontain(club[j],reg[k])&&dist[k][i]<mmin)
     mmin=dist[k][i];
   }
   sum+=mmin;
  }
  if(sum<MIN)
   MIN=sum;
 }
 printf("%d\n",MIN);
 return 0;
}

Input

Output

Sample Input

2
2 2
1 2 13
2 1 33
4 6
1 2 10
2 1 60
1 3 20
3 4 10
2 4 5
4 1 50

Sample Output

46
210

 
解题思路
题意：
题目意思是要把学生从1这个站送到所有的站，并把它们送回到1所要用的最小费用，是一个求最短路径的题。
思路：
由于用普通邻接矩阵来做的话会超内存，因为1 <= P,Q <= 1000000.故采取邻接表存储方式。这里我分别记录了邻接表
和逆邻接表，因为最后要把学生都送回1站。然后用spfa算法，求最短路径。由于是第一次学spfa，居然6625MS险过，开
始还TLE了几次，但是实在不懂怎么优化，希望有大牛指点下。源代码如下：
源程序
#include<iostream>
#include<queue>
using namespace std;
const int INF=1100000000;
const int MAXN=1000005;
struct node
{
 int v;
 int w;
 node *next;
};
node *adj[MAXN];
node *inv[MAXN];
__int64 dist[MAXN];
int visit[MAXN];
queue<node>q;
void add(int i,int v,int w,node *p[])
{
 node *q=new node[1];
 q->v=v;
 q->w=w;
 q->next=p[i];
 p[i]=q;
}
__int64 spfa(int s,int n,node *p[])
{
 int i;
 for(i=1;i<=n;i++)
 {
  dist[i]=INF;
  visit[i]=0;
 }
 node ns;
 ns.v=s;
 ns.w=0;
 visit[s]=1;
 dist[s]=0;
 q.push(ns);
 while(!q.empty())
 {
  node now=q.front();
  q.pop();
  visit[now.v]=0;
  for(node *m=p[now.v];m;m=m->next)
  {
   if(dist[m->v]>dist[now.v]+m->w)
   {
    dist[m->v]=dist[now.v]+m->w;
    if(!visit[m->v])
    {
     visit[m->v]=1;
     ns.v=m->v;
     ns.w=m->w;
     q.push(ns);
    }
   }
  }
 }
 __int64 ans=0;
 for(i=1;i<=n;i++)
  ans+=dist[i];
 return ans;
}
int main()
{
 int t,P,Q,i,a,b,c;
 scanf("%d",&t);
 while(t--)
 {
  scanf("%d%d",&P,&Q);
  for(i=1;i<=P;i++)
  {
   adj[i]=NULL;
   inv[i]=NULL;
  }
  for(i=1;i<=Q;i++)
  {
   scanf("%d%d%d",&a,&b,&c);
   add(a,b,c,adj);
   add(b,a,c,inv);
  }
  printf("%I64d\n",spfa(1,P,adj)+spfa(1,P,inv));
 }
 return 0;
}

Input

Output

Sample Input

2
3 3
1 2 1
2 3 2
3 1 3
4 4
1 2 2
2 3 2
3 4 2
4 1 2

Sample Output

3
Not Unique!

 
解题思路
题意：
题目意思很明显，求最小生成数。不同的是他要让你判断最小生成树是否唯一，如果不唯一的话输出Not Unique!否则输出最小生成树的总cost。
思路：
最小生成树没什么说的，关键是如何判断唯一性，我采用的方法是先找出一颗最小生成数，并记录他的边，然后依次把记录的边去掉再求他最小生成树，如果这时求到的结果还是等于第一颗的
结果，说明最小生成树不唯一。一种笨方法，希望大牛能提供更好的算法。源代码如下：
源程序
#include<iostream>
using namespace std;
const int INF=1000000000;
int N,M;
int edge[101][101];
int Min[101];
int m[101][2];
int close[101];
bool unique;
bool primnum(int x,int y,int n,int sum);
int prim(int n,int mat[][101],int Min[]);
int main()
{
 int t,i,j,x,y,w;
 cin>>t;
 while(t--)
 {
  cin>>N>>M;
  for(i=1;i<=N;i++)
  {
   for(j=1;j<=N;j++)
    edge[i][j]=INF;
  }
  for(i=1;i<=M;i++)
  {
   cin>>x>>y>>w;
   edge[x][y]=edge[y][x]=w;
  }
  int ans=prim(N,edge,Min);
  if(unique==true)
   cout<<ans<<endl;
  else
   cout<<"Not Unique!"<<endl;
  unique=false;
 }
 return 0;
}
bool primnum(int x,int y,int n,int sum)
{
 int mmat[101][101];
 int v[101];
 int i,j,k,ret=0;
 for(i=1;i<=n;i++)
 {
  v[i]=0;
  Min[i]=INF;
 }
 for(i=1;i<=n;i++)
 {
  for(j=1;j<=n;j++)
   mmat[i][j]=edge[i][j];
 }
 mmat[x][y]=mmat[y][x]=INF;
 for(Min[1]=0,i=1;i<=n;i++)
 {
  for(k=-1,j=1;j<=n;j++)
  {
   if(!v[j]&&(k==-1||Min[j]<Min[k]))
     k=j;
  }
  if(Min[k]==INF)
   return false;
  for(v[k]=1,ret+=Min[k],j=1;j<=n;j++)
  {
   if(!v[j]&&(mmat[k][j]<Min[j]))
    Min[j]=mmat[k][j];
  }
 }
 if(ret==sum)
  return true;
 return false;
}
int prim(int n,int mat[][101],int Min[])
{
 int i,j,k,ret=0,mm=0;
 int v[101];
 for(i=1;i<=n;i++)
 {
  v[i]=0;
  Min[i]=INF;
  close[i]=1;
 }
 for(Min[1]=0,i=1;i<=n;i++)
 {
  for(k=-1,j=1;j<=n;j++)
  {
   if(!v[j]&&(k==-1||Min[j]<Min[k]))
     k=j;
  }
  m[mm][0]=close[k],m[mm++][1]=k;
  for(v[k]=1,ret+=Min[k],j=1;j<=n;j++)
  {
   if(!v[j]&&(mat[k][j]<Min[j]))
   {
    Min[j]=mat[k][j];
    close[j]=k;
   }
  }
 }
 for(i=1;i<mm;i++)
 {
  if(primnum(m[i][0],m[i][1],n,ret))
   break;
 }
 if(i==mm)
  unique=true;
 else
  unique=false;
 return ret;
}

Input

Output

Sample Input

1 2 3 4 5

Sample Output

4

 
解题思路
题意：中文。。。
 
思路：
首先先诉下苦。。此题我整整研究了一下午，因为好多东西都不了解，所以花了非常多的时间，但总算是把好多东西都理清
了，好多东西都把它关联了起来，对于像我一样的新手来说，这篇报告估计比较好用，对牛牛来说。。当然就会嫌我太罗嗦
哈。。。下面正文（推理全都是自己研究成果，如有错误，忘大牛提示。。ps：希望没错。。哈）：
根据题意，青蛙若想碰面的话，则必有(x+mt)-(y+nt)=p*L;(p为任意整数)。方程化为：(m-n)t-(y-x)=pL;则有
((m-n)t-(y-x))mod(L)=0(mod为取模运算)。即为：(m-n)t mod L=y-x;为线性同余方程。此方程有解当且仅当y-x能
被m-n和L的最大公约数(记为gcd(m-n,L)),即gcd(m-n,L)|y-x。这时，如果x0是方程的一个解，即当t=x0时，
(m-n)t mod L=y-x成立，那么所有的解可以表示为：
{x0+k(L/gcd(m-n,L))|(k∈整数)}。
设d=gcd(m-n,L)，根据裴蜀定理，则必存在整数对(r,s)使得(m-n)*r+L*s=d;则可得t=r*(y-x)/d。证明：把t代入
得：(m-n)t-(y-x)=((m-n)r(y-x)-d(y-x))/d=
((y-x)((m-n)r-d))/d=(y-x)*(-L*s)/d.因为d|y-x,所以L|(y-x)*(-L*s)/d。即
((m-n)t-(y-x))mod(L)=0成立。所以问题转换为求r，也就是解一个含2个数的不定方程(m-n)*r+L*s=d。
下面在讨论求解不定方程的解法：
求解ax+by=gcd(a,b).
ax+by=gcd(a,b)=gcd(b,a%b)(欧几里德求最大公约数算法)。
gcd(b,a%b)=b*x'+(a%b)*y'.
所以有ax+by=b*x'+(a%b)*y'=b*x'+(a-a/b*b)*y'=ay'+b(x'-a/b*y').
因此由对比系数法得：x=y';y=x'-a/b*y'。
由这个得出扩展的欧几里德算法：
int exGcd(int a, int b, int &x, int &y)
{
if(b == 0)
{
       x = 1;
       y = 0;
       return a;
}
int r = exGcd(b, a % b, x, y);
int t = x;
x = y;
y = t - a / b * y;
    return r;
}//返回a和b的最大公约数。
原代码如下：
源程序
#include<iostream>
using namespace std;
__int64 exGcd(__int64 a,__int64 b, __int64 &xx, __int64 &yy);
int main()
{
       __int64 x,y,m,n,L,xx,yy;
       scanf("%I64d%I64d%I64d%I64d%I64d",&x,&y,&m,&n,&L);
       __int64 d=exGcd(n-m,L,xx,yy);
       if((x-y)%d!=0)
              cout<<"Impossible"<<endl;
       else
       {
              xx=xx*((x-y)/d);
              int s=L/d;
              xx=(xx%s+s)%s;
              printf("%I64d\n",xx);
       }
       return 0;
}
__int64 exGcd(__int64 a,__int64 b, __int64 &xx, __int64 &yy)
{
       if(b == 0)
       {
       xx = 1;
       yy = 0;
       return a;
       }
       __int64 r = exGcd(b, a % b, xx, yy);
       __int64 t = xx;
       xx = yy;
       yy = t - a / b * yy;
    return r;
}

Input

Output

Sample Input

2
3
pnp
6
4
ppnn
10

Sample Output

Impossible
1110

 
解题思路
题意：
题目意思是有一个k位的2进制的数，把他转化成10进制，如果可以转换得到题目要求的数，则输出那个2进制数。但是转换成10进制数固定的加，它还可以减。题目会给出哪一位是+，哪一位
是-，分别由p和n代表。比如：
4
ppnn
10
意思是有一个4位的2进制数ppnn代表++--。这里可以这样组合：1110.因为2^3+2^2-2^1-0=10.所以输出1110.
思路：
这道题我的思路是从最后一位开始判断，如果N是奇数，那么说明最后一位肯定是1。因为只有最后一位才是0次方，才有可能得到唯一的奇数1.这时如果最后那位是p也就是+时就把N-1。再提
出一个2，也就是除以2，得到前面的k-1位所得到的数。如果N是偶数，可以断定最后一位是0，那么直接除以2得到前面k-1位得到的数。依次循环至剩下0位即可。如果循环完毕N没有等于0，
可以判断为impossible。注：因为可以存在负数，上述考虑都是排除负数的情况，有负数也没关系，判断N%2==-1就行了。源代码如下：


 
源程序
#include<iostream>
using namespace std;
char s[68];
__int64 N;
int k;
int ans[68];
int an;
int main()
{
       int t,i;
       cin>>t;
       while(t--)
       {
              cin>>k;
              cin>>s;
              scanf("%I64d",&N);
              for(i=k-1;i>=0;i--)
              {
                     if(N%2==1||N%2==-1)
                     {
                            if(s[i]=='p')
                            {
                                   N-=1;
                                   N/=2;
                            }
                            else
                            {
                                   N+=1;
                                   N/=2;
                            }
                            ans[an++]=1;
                     }
                     else
                     {
                            N/=2;
                            ans[an++]=0;
                     }
              }
              if(N!=0)
                     cout<<"Impossible";
              else
              {
                     for(i=k-1;i>=0;i--)
                            cout<<ans[i];
              }
              cout<<endl;
              an=0;
       }
       return 0;
}

Input

Output

Sample Input

1 0
2 3
1 2 37
2 1 17
1 2 68
3 7
1 2 19
2 3 11
3 1 7
1 3 5
2 3 89
3 1 91
1 2 32
5 7
1 2 5
2 3 7
2 4 8
4 5 11
3 5 10
1 5 6
4 2 12
0

Sample Output

0
17
16
26

 
解题思路
题意：
题目意思就是给你点，代表两个位置。边代表点之间连通可能需要得电缆长度，
注意这里是说可能需要得，所以会出现相同得点与点之间需要得电缆长度不同。最后让你求要把所有点连通需要得最少得电
缆长度。
思路：
这题完完全全是一个最小生成树。用prim就可以解决，输入得时候要注意判断是否重复，若重复则取两者之间最小值，再调
用prim求出ans。源代码如下：
 
源程序
#include<iostream>
using namespace std;
#define MAX 100000
int P,R;
int route[105][105];
int close[105];
int prim();
int main()
{
       int i,a,b,c;
       while(cin>>P&&P)
       {
              cin>>R;
              if(R==0)
              {
                     cout<<0<<endl;
                     continue;
              }
              for(i=1;i<=R;i++)
              {
                     cin>>a>>b>>c;
                     if(route[a][b]!=0)
                            route[b][a]=route[a][b]=route[a][b]<c?route[a][b]:c;
                     else
                            route[b][a]=route[a][b]=c;
              }
              cout<<prim()<<endl;
              memset(route,0,sizeof(route));
       }
       return 0;
}
int prim()
{
       int i,j,sum(0);
       int v[MAX];
       for(i=1;i<=P;i++)
       {
              close[i]=route[1][i];
              v[i]=0;
       }
       v[1]=1;
       int vv;
       for(i=1;i<=P;i++)
       {
              int min=INT_MAX;
              for(j=1;j<=P;j++)
              {
                     if(!v[j]&&close[j]&&close[j]<min)
                     {
                            min=close[j];
                            vv=j;
                     }
              }
              if(min!=INT_MAX)
                     sum+=min;
              for(v[vv]=1,j=1;j<=P;j++)
              {
                     if(!v[j]&&route[vv][j]&&(close[j]>route[vv][j]||close[j]==0))
                            close[j]=route[vv][j];
              }
       }
       return sum;
}

Input

Output

Sample Input

6 9
....#.
.....#
......
......
......
......
......
#@...#
.#..#.
11 9
.#.........
.#.#######.
.#.#.....#.
.#.#.###.#.
.#.#..@#.#.
.#.#####.#.
.#.......#.
.#########.
...........
11 6
..#..#..#..
..#..#..#..
..#..#..###
..#..#..#@.
..#..#..#..
..#..#..#..
7 7
..#.#..
..#.#..
###.###
...@...
###.###
..#.#..
..#.#..
0 0

Sample Output

45
59
6
13

 
解题思路
题意：
#代表红，.代表黑，@代表当前位置，让你从当前位置出发，只能踩旁边的点而且该点为黑，问最多能踩几个。
思路：
本题我采取递归的方法。设go(x,y)为从点(x,y)出发能踩的最多的数，则有公式：
go(x,y)=1+go(x-1,y)+go(x+1,y)+go(x,y-1)+go(x,y+1)。要注意踩了的点应标记成红#。源代码如下：
源程序
#include<iostream>
using namespace std;
char a[30][30];
int W,H;
int go(int x,int y);
int main()
{
       int i,j;
       while(cin>>W>>H&&(W+H))
       {
              for(i=0;i<H;i++)
                     cin>>a[i];
              for(i=0;i<H;i++)
              {
                     for(j=0;j<W;j++)
                     {
                            if(a[i][j]=='@')
                            {
                                   cout<<go(i,j)<<endl;
                                   break;
                            }
                     }
              }
       }
       return 0;
}
int go(int x,int y)
{
       if(x<0||y<0||x>=H||y>=W)
              return 0;
       if(a[x][y]=='#')
              return 0;
       else
       {
              a[x][y]='#';
              return 1+go(x-1,y)+go(x+1,y)+go(x,y-1)+go(x,y+1);
       }
}

Input

Output

Sample Input

4 2
10 5
49 6
0 0

Sample Output

6
252
13983816
 
解题思路
题意：
求组合。
思路：
此题就是一道数学题，求组合C。思路没什么讲的，关键要注意TLE的问题和WA的问题，因为连乘可能超过__int64的范围，
TLE的话就要把k转换成n-k就行了。源代码如下：

 
源程序
#include<iostream>
using namespace std;
int main()
{
       __int64 n,k;
       __int64 ans(1);
       int i,j;
       while(scanf("%I64d%I64d",&n,&k)&&(n+k))
       {
              if(k==0||k==n)
              {
                     cout<<1<<endl;
                     continue;
              }
              if(k>n/2)
                     k=n-k;
              j=i=k;
              while(i)
              {
                     ans*=n;
                     if(ans%j==0)
                     {
                            ans/=j;
                            j--;
                     }
                     n--;
                     i--;
              }
              for(j;j>1;j--)
                     ans/=j;
              printf("%I64d\n",ans);
              ans=1;
       }
       return 0;
}