#include<stdio.h>
void func(int i)
{
int m,n,k,j;
int temp,vmax=4*i+2;
for(m=1;m<i;m++)
for(n=m;n<=i;n++)
{
j=m*n;//避免了三重循环
if(j>i)
break;//能省不少时间
if(i%j==0)//判断是否能整除
{
k=i/j;
temp=2*(k*m+k*n+j);
if(temp<vmax)
vmax=temp;
}
}
printf("%d\n",vmax);
}
int main()
{
int num,n;
scanf("%d",&num);
getchar();
while(num--)
{
scanf("%d",&n);
getchar();
func(n);
}
//system("PAUSE");
return   0;
}

Sample input

3
7
9901

Output for sample input

3
6
12

可以不用高精度除法，直接如下，很巧妙，不通用。

#include <stdio.h>
int main()
{
int n, a, b;
while (EOF != scanf("%d", &n))
{
a = 1;
b = 1;
while (a)
{
a = (a * 10 + 1) % n;
++b;
}
printf("%d\n", b);
}
}

高精度除法
----
#include<iostream>
#include<cstdlib>
using namespace std;
int a[9]={1,11,111,1111,11111,111111,1111111,11111111,111111111};
const int MOD=11111;
  bool test(int i,int j)
  {
  if(j<10)
  {
   if(a[j-1]%i==0)
   return true;
   return false;
  }
  else
  {
   int temp=0;
   int k=j%5;
   int p=j/5;
   if(k==0)
   {
    for(int m=1;m<=p;m++)
       {
     temp*=100000;
        temp+=MOD;
        temp%=i;
       
       }
       if(temp==0)
       return true;
       else
       return false;
     }
     else
     {
    int m,f=1;
    for(m=1;m<=p;m++)
       {
        temp*=100000;//由于5位5位除，应当乘上10^5;
     temp+=MOD;
        temp%=i;
       
       }
       for(m=0;m<k;m++)//最后应当乘以其后的位数乘10^n，
       f*=10;
     if((temp*f+a[k-1])%i==0)
     return true;
     else
     return false;
     }
   
  }
  }
  int main()
  {
  //freopen("s.txt","r",stdin);
  //freopen("key.txt","w",stdout);
  int i;
  while(cin>>i)
  {
  if(i==1)
  {
   cout<<'1'<<endl;
   continue;
  }
  for(int j=2;;j++)
  {
   if(test(i,j))
   {
    cout<<j<<endl;
    break;
   }
      }
  }

  //system("PAUSE");
  return   0;
  }

3
joj
jlu
acm
6
cctv
redcode
lindong
we
love
programming
3
daoyuanlee
come
on

6
11
10

Problem Source: provided by loon

#include<iostream>
#include<cstdlib>
using namespace std;
struct S
{
 string a;
 char begin;
 char end;
 int length;
 }s[13];
 int visited[13];
int temp; 
void search(int a,int num,int pre)
 {
  
  for(int i=0;i<num;i++ )
  {
   if(s[i].begin==s[pre].end&&visited[i]==0)
   {
    visited[i]=1;
    search(a+s[i].length,num,i);
    if(a+s[i].length>temp)temp=a+s[i].length;
    visited[i]=0;
   }
  }
 }
  int main()
  {
  freopen("s.txt","r",stdin);
  freopen("key.txt","w",stdout);
   int num;
   while(cin>>num)
   {
    int i;
  temp=0;
  for( i=0;i<num;i++)
  {
   cin>>s[i].a;
   s[i].length=(s[i].a).size();
   s[i].begin=(s[i].a)[0];
   s[i].end=(s[i].a)[s[i].length-1];
   if(s[i].length>temp)
   temp=s[i].length;
     }
  for(i=0;i<num;i++) 
     {
   memset(visited,0,sizeof(visited));
   visited[i]=1;
   search(s[i].length,num,i);
  }
  cout<<temp<<endl;
 }

  //system("PAUSE");
  return   0;
  }

以上代码超时。完全可以剪枝。
举个例子
abc
cbd
dbm
dbacmdp
我的程序一直搜啊搜，每次搜完都重新开始。比如在以a开头后，搜到c，下次再搜索时直接利用c的结果，这是深搜的特点决定的！！！
*************************
这种类似的有序搜索都可以用     *  备忘录方法*
**************************
#include<iostream>
#include<cstdlib>
using namespace std;
int num;
struct S
{
 string a;
 char begin;
 char end;
 int length;
 }s[13];
 int visited[13];
int temp;
int sum[13]; 
int search(int pre)//·µ»Ø´ÓpreµãÒÔºóµÄ×ܵÄÖµ
 {
  int j=s[pre].length,k=0;
  for(int i=0;i<num;i++ )
  {
   if(s[i].begin==s[pre].end&&visited[i]==0&&i!=pre)//必须要有I！=pre
   {
    visited[i]=1;
    k=search(i)+s[pre].length;
    if(k>j)j=k;
   }
   else
   {
    if(s[i].begin==s[pre].end&&i!=pre)//必须要有i!=pre
    return sum[i]+s[pre].length;//相当于备忘录，而且无需visited[i]=0;
   }
  }
  sum[pre]=j;
  return j;
 }
  int main()
  {
 freopen("s.txt","r",stdin);
  freopen("key.txt","w",stdout);
   while(cin>>num)
   {
    int i,j;
  temp=0;
  j=0;
  for( i=0;i<num;i++)
  {
   cin>>s[i].a;
   s[i].length=(s[i].a).size();
   s[i].begin=(s[i].a)[0];
   s[i].end=(s[i].a)[s[i].length-1];
   if(s[i].length>temp)
   temp=s[i].length;
     }
  for(i=0;i<num;i++) 
     {
   memset(visited,0,sizeof(visited));
            memset(sum,0,sizeof(sum));
   visited[i]=1;
   j=search(i);
   if(j>temp)
   temp=j;
  }
  cout<<temp<<endl;
 }

  //system("PAUSE");
  return   0;
  }

因为I！=pre又错了几下。
以后debug尽量自己用眼睛看，更省时间！！！！！！！！！

Status	In/Out	TIME Limit	MEMORY Limit	Submit Times	Solved Users	JUDGE TYPE
	stdin/stdout	3s	10240K	717	196	Standard

5
8 0 6 4 -1
-1

18

理解题意很重要，题目的意思是说 在m个中选   连续的n个atom能量值 使其最大。
程序中sumtemp，sum。sumtemp确定的是其左边界，sum确定其右边界。
sumtemp确定左边前n个数之和为负的最大的n，且第n个数显然为负，然后从n+1开始选数。
sum确定了右边界使其最大。
求和最大都可以用这种思路！！！！！！！！！！
举例
1，2，-4，4，2，-2，1，5，-6，5，-3，8，10
请看sumt1=1,sum=1
sumt2=2;sum=1+2=3;
sum3=sum2-4=-1;则sumtemp=0;sum不变。
sum4=sumtemp+4;sum<sum4,sum=4;
sum5=sumtemp+2；sum<sum5,sum=6
总之sum只有在sum<sumtemp时才修改。sumtemp<0则清0.
一维dp.
#include"stdio.h"
int main()
{
 freopen("s.txt","r",stdin);
  freopen("key.txt","w",stdout);
 int n;
 int a;
 while(scanf("%ld",&n),n!=-1)
 { 
      long long  sum=-0x7fffffff,sumtemp=-0x7fffffff;
   for(long i=0;i<n;i++)
   { 
    scanf("%d",&a);
    if(sumtemp>0)
   sumtemp+=a;
    else
   sumtemp=a;
    if(sumtemp>sum)
   sum=sumtemp;

   }
   printf("%lld\n",sum);

 }
 return 0;
}

  int  dfs(int sum,int flag,int n,int time)//´Ótime¿ªÊ¼ËÑË÷
  {
  if(sum==0)return 1;
    if(time<n)
  {
   for(int k=time;k<n;k++)
   {
    if(mark[k]<0&&sum-length[k]>=0)
    {
     mark[k]=flag;
     if(dfs(sum-length[k],flag,n,k+1))
     return 1;
     else
     mark[k]=-1;
       } 
   }
  }
    
 return 0;
  }
  int main()
  {
  freopen("s.txt","r",stdin);
  freopen("key.txt","w",stdout);
  int num,n;
 
  cin>>num;
  while(num--)
  {
  int sum=0;
  cin>>n;
  for(int k=0;k<n;k++)
  {
   cin>>length[k];
   mark[k]=-1;
   sum+=length[k];
  }
  sort(length,length+n,cmp);
  if(sum%4!=0||length[0]>sum/4)
  cout<<"no"<<endl;
  else
  {
   sum/=4;
   if(dfs(sum,1,n,0))
    {
   if(dfs(sum,2,n,0))
          {
     if(dfs(sum,3,n,0))
     cout<<"yes"<<endl;
     else
     cout<<"no"<<endl;
        } 
        else
        cout<<"no"<<endl;
          }
         else
         cout<<"no"<<endl;
  }
    }
  //system("PAUSE");
  return   0;
  }
正确的解法应当是，在一起搜索。
下面是一段超时的代码
#include<iostream>
#include<cstdlib>
#include<algorithm>
using namespace std;
 int length[21];
 int mark[21];
 int flag=0;
 int target;
 bool cmp(int x,int y)
{
    return x>y;
}

  int func(int i)
  {
  while(mark[i]>0)
  i++;
  return i;
 }
  void  dfs(int sum,int n,int time,int level)//从序号为time的开始搜索
  {
  if(flag)return ;
  if(sum==0&&level==3)
  {
  flag=1;
  return;
     }
     if(sum==0)
     {
   level++;
   dfs(target,n,func(0),level);
  }
    else if(time<n)
  {
   for(int k=time;k<n;k++)
   {
    if(k>1)
               {
               
                if(length[k]==length[k-1]&&!mark[k-1])
                    continue;//显然
               }
                if(sum<length[n-1])  continue;//显然
    if(mark[k]<0&&sum-length[k]>=0)
    {
     mark[k]=1;
     dfs(sum-length[k],n,func(k+1),level);
     mark[k]=-1;
       } 
   }
  }
  }
  int main()
  {
  freopen("s.txt","r",stdin);
  freopen("key.txt","w",stdout);
  int num,n;
 
  cin>>num;
  while(num--)
  {
  int sum=0;
  cin>>n;
  for(int k=0;k<n;k++)
  {
   cin>>length[k];
   mark[k]=-1;
   sum+=length[k];
  }
  sort(length,length+n,cmp);
  if(sum%4!=0||length[0]>sum/4)
  cout<<"no"<<endl;
  else
  {
   sum/=4;
   target=sum;
   dfs(sum,n,0,0);
       if(flag==0)
       cout<<"no"<<endl;
       else
       cout<<"yes"<<endl;
  }   
    }
  //system("PAUSE");
  return   0;
  }

上面超时就超时原因是减枝不彻底。level标记也不太好
决定另外炉灶,先看看别人的代码
#include<iostream>
#include<algorithm>
using namespace std;
int s[21];
int v[21];
int len;
int m;
int dfs(int cur,int num,int beg,int fin)
{    
 int solve(int );
 if(num==1)
  return 1;
 if(cur==len)
 {
  return solve(num-1);
 }
   for(int i=beg;i>=fin;i--)
   {
    if(!v[i]&&cur+s[i]<=len)
    {  
     v[i]=1;
     if(dfs(cur+s[i],num,i-1,fin))
      return 1;
     v[i]=0;
    }
   }
   return 0;
}

int solve(int edge_num)
{   
     int i;
  for(i=m;i>=1;i--)
   if(!v[i])
   { 
    v[i]=1;
    if(dfs( s[i],edge_num,i-1,1))
     return 1;
    v[i]=0;
   }
 return 0;
}

int main()
{
 int n;
 cin>>n;
 while(n--)
 {
  
  cin>>m;
  int i;
  int sum=0;
  for(i=1;i<=m;i++)
  {
   cin>>s[i];
   sum+=s[i];
   v[i]=0;
  }
  
  len=sum/4;
  if(4*len!=sum)
  {
   cout<<"no"<<endl;
   continue;
  }
  sort(s+1,s+m+1);
  if(s[m]>len)
  {
   cout<<"no"<<endl;
   continue;
  }
  if(solve(4))
   cout<<"yes"<<endl;
  else
   cout<<"no"<<endl;
 }
 return 0;
}//剪枝还可以做得更好！！！
人家的solve写得好！！，结合dfs.

Status	In/Out	TIME Limit	MEMORY Limit	Submit Times	Solved Users	JUDGE TYPE
	stdin/stdout	15s	8192K	479	114	Standard

3
100
90
200

190 200

利用dp思想 ，n为偶数时求出s(n,n/2)，n为奇数时 也是s(2n,n/2)，和sum/2最接近的那个。非常经典的思路。
S(k, 1) = {A[i] | 1<= i <= k}
S(k, k) = {A[1]+A[2]+…+A[k]}
S(k, i) = S(k-1, i) U {A[k] + x | x属于S(k-1, i-1) }
//一下代码只能用于sum特别小的情况，否则会超时！！！！！！！！！！！
#include<iostream>
#include<cstdlib>
#define MAX 101
#define min(a,b) ((a)<(b) ? (a) : (b))
using namespace std;

  int main()
  {
  freopen("s.txt","r",stdin);
  freopen("key.txt","w",stdout);
  int num;
  int a[MAX],i,j,k,l,m,NUM;
  bool s[MAX][2500];
  while(cin>>num)
  {
  int sum=0;
    for(i=1;i<=num;i++)
   {
  cin>>a[i];
  sum+=a[i]; 
   }
   if(num%2==0)NUM=num/2;
   else NUM=num/2+1;

    for(i=0;i<=num;i++)
     for(j=0;j<=sum/2;j++)
      s[i][j]=false;//表示取i个物品能否达到重量是j.
     
   s[0][0]=true;
   for(k=1;k<=num;k++)//必须在最外层，元素不能重复
   for(j=min(k,NUM);j>=1; j--)//递减的结果是使得不会出现在同一层次的互为因果 、、、、、、、、、、、巧妙的实现了课本上的序偶对生成法。
   for(i=a[k];i<=sum/2;i++)
   {
  if(s[j-1][i-a[k]])
  s[j][i]=true;
 }
 
 for(i=sum/2; i>=0; i--) {  
    if(s[NUM][i]) {  
        cout <<i<<" "<<sum-i<<endl;  
        break;  
    }  
} 

  }
  //system("PAUSE");
  return   0;
  }
下一次实现一个序偶生成法。

#include <iostream>
#include <functional>
using namespace std;

int a[101];
bool b[101][45002];

int main(){
// freopen("s.txt","r",stdin);
//  freopen("key.txt","w",stdout);
    int N,M,i,j,k;
    while(scanf("%d",&N)!=EOF){
         memset(b,0,sizeof(b));
         a[0]=M=0;
        for(i=1;i<=N;i++){
             scanf("%d",a+i);
             M+=a[i];
         }
         b[0][0]=1;
        for(k=1;k<=N;k++){
            for(i=1;i<=N/2;i++){
                for(j=M/2;j>=0;j--){
                    if(b[i-1][j]){
                         b[i][j+a[k]]=1;
                     }
                 }
             }
         }
        for(i=M/2,j=M/2+1;i>=0;i--,j++){
            if(b[N/2][i]){
                 printf("%d %d\n",i,M-i);
                break;
             }
            if(b[N/2][j]){
                 printf("%d %d\n",M-j,j);
                break;
             }
         }
     }
    return 0;
}

Output

Print a new line after each test case.

Sample Input

2
1
1 2
0 0
5
3
1 2
3 5
3 1
2 4
4 5
0 0
5
5
5 1
5 2
5 3
5 4
4 1
4 2
0 0
0

Sample Output

Case 1: The longest path from 1 has length 1, finishing at 2.
Case 2: The longest path from 3 has length 4, finishing at 5.
Case 3: The longest path from 5 has length 2, finishing at 1.

提交了10次，AC 3次，超时4次，wa 3次。

很无语。

应该是动态规划最好，但是我不是很熟，用了搜索。以下是超时的代码

#include<iostream>
#include<cstdlib>
using namespace std;
int path[101][101];
int mark[101];
int len[101];//
int end[101];
int dfs(int start,int num)//返回从当前点出发的最大长度
{
if(mark[start]==1)return len[start];
mark[start]=1;
end[start]=start;
for(int i=1;i<=num;i++)
{
if(path[start][i])
{
if(len[start]<dfs(i,num)+1)
{
len[start]=len[i]+1;
end[start]=end[i];
}
else
if(len[start]==len[i]+1&&end[start]>end[i])
end[start]=end[i];
}
}
mark[start]=0;//这句坚决不需要 
return len[start];
}
int main()
{
// freopen("s.txt","r",stdin);
//freopen("key.txt","w",stdout);
int j,k,turn=0;
int start,num;
while(cin>>num)
{
turn++;
if(num==0)break;
memset(path,0,sizeof(path));
memset(mark,0,sizeof(mark));
memset(len,0,sizeof(len));
memset(end,0,sizeof(end));
cin>>start;
while(cin>>j>>k)
{
if(j==0)break;
path[j][k]=1;
}
cout<<"Case "<<turn<<": The longest path from "<<start<<" has length "<<dfs(start,num)<<", finishing at "<<end[start]<<"."<<endl<<endl;
}
//system("PAUSE");
return   0;
}
以下是ac的代码
#include<iostream>
#include<cstdlib>
using namespace std;
int path[102][102];
int mark[102], len[102],end[102];
int dfs(int start,int num)//返回从当前点出发的最大长度
{
if(mark[start]==1)return len[start];
mark[start]=1;
end[start]=start;
len[start]=0;
int i,t;
for( i=1;i<=num;i++)
{
if(path[start][i])
{
t=dfs(i,num)+1;
if(t>len[start])
{
len[start]=t;
end[start]=end[i];
}
else
if(len[start]==t)
{
if(end[start]>end[i])
end[start]=end[i];
}
}
}
return len[start];
}
int main()
{
//freopen("s.txt","r",stdin);
//freopen("key.txt","w",stdout);
int j,k,turn=0;
int start,num;
while(cin>>num,num)
{
turn++;
memset(path,0,sizeof(path));
memset(mark,0,sizeof(mark));
memset(len,0,sizeof(len));
memset(end,0,sizeof(end));
cin>>start;
while(cin>>j>>k,j||k)
{
path[j][k]=1;
}
dfs(start,num);
cout<<"Case "<<turn<<": The longest path from "<<start<<" has length "<<len[start]<<", finishing at "<<end[start]<<"."<<endl<<endl;
}
//system("PAUSE");
return   0;
}
不妨执行一下
5
3
1 2
3 5
3 1
2 4
4 5
0 0
先是len[3]=0;end[3]=3;flag[3]=1;
再执行t=dfs(1)+1,
转入dfs（1）；len[1]=0;end[1]=1;flag[1]=1;
再执行t=dfs(2)+1;
转入dfs(2),len[2]=0;end[2]=2;flag[2]=1;
再执行t=dfs(4)+1
转入dfs(4),len[4]=0;end[4]=4;flag[4]=1;
再转入t=dfs（5)+1;
转入dfs(5),len[5]=0;end[5]=5;flag[5]=1;return(len[5]=0);
则t=1;t>len[4];len[4]=1;end[4]=end[5]=5;再看4没了其他相邻元素。dfs(4)=return(len[4])=1;
t=dfs(4)+1=2;len[2]=t=2;end[2]=end[4]=5;再看2没了其他相邻元素，dfs(2)=return(len(2)=2;
再看t=dfs(2)+1=3;len[1]=t=3;end[1]=en[2]=5;再看1有没有其他相邻元素，dfs(1)=return(len(1)=3
再执行t=dfs(1)+1,len[3]=4;end[3]=end[1]=5;再看3有没有其他相邻元素，有dfs(5),已经遍历到了，所以dfs（5）return len【5】。
没有影响。
假设改为
5
3
5 2
3 5
3 1
2 4
4 1
0 0
执行时会走3->1>这时的1结点len[1]已经求的   3>5>2>4>1len[1]已知了

  //system("PAUSE");
  return   0;
  }

Your teacher has given you some problems to solve. You must first solve problem 0. After solving each problem i, you must either move on to problem i+1 or skip ahead to problem i+2. You are not allowed to skip more than one problem. For example, {0, 2, 3, 5} is a valid order, but {0, 2, 4, 7} is not because the skip from 4 to 7 is too long.
You are given N integers, where the ith integer indicates how much you like problem i. The teacher will let you stop solving problems once the range of pleasantness you've encountered reaches a certain threshold. Specifically, you may stop once the difference between the maximum and minimum pleasantness of the problems you've solved is greater than or equal to a integer K. If this never happens, you must solve all the problems.
Input
The input contains several test cases. For each case it contains two positive integer N, K (1<=N<=50, 1<=K<=1000), then N integers follow in the next line, the ith integer ( >=1 and <= 1000 ) indicates how much you like problem i.

Output
For each test case, output the minimum number of problems you must solve to satisfy the teacher's requirements.
Sample Input
3 2
1 2 3
5 4
1 2 3 4 5
Sample Output
2
3 

很笨但是很实用！
#include<stdio.h>
int a[51];
int main()
{
int n,k;
while(scanf("%d%d",&n,&k)!=EOF)
{
int i,j;
for(i=0;i<n;i++)
scanf("%d",a+i);
int min=0xfffffff;
int flag=0;
for(i=1;i<n;i++)
for(j=0;j<i;j++)
{
if(a[i]-a[j]>=k||a[j]-a[i]>=k)
{
flag=1;
int step;
if(j==0)
{
step=(i+1)/2+1;
if(min>step)
min=step;
}
else
{
step=(i-j+1)/2+(j+1)/2+1;
if(min>step)
min=step;
}
}
}
if(flag)
printf("%d\n",min);
else
printf("%d\n",n);
}
return 0;
}

将乘法转化为log加法！！！

One curious child has a set of N little bricks. From these bricks he builds different staircases. Staircase consists of steps of different sizes in a strictly descending order. It is not allowed for staircase to have steps equal sizes. Every staircase consists of at least two steps and each step contains at least one brick. Picture gives examples of staircase for N=11 and N=5:

Your task is to write a program that reads from input numbers N and writes to output numbers Q - amount of different staircases that can be built from exactly N bricks.

Input

Output

Sample Input

3
5
0

Sample Output

1
2

#include<iostream>
#include<string>
#include<map>
using namespace std;

int main()
{
 freopen("s.txt","r",stdin);
  freopen("key.txt","w",stdout);
    string s;
    int g=0;
    while(getline(cin,s))
    {
        if (g) cout<<endl;
        g=1;
        int sum=0;
        map<string,int> a;
        while(s!="")
        {
            a[s]++;
            sum++;
            getline(cin,s);
        }
        cout.flags(ios::fixed);
        cout.precision(4);
        for (map<string,int>::iterator p=a.begin();p!=a.end();p++)
            cout<<p->first<<" "<<100.0*p->second/sum<<endl;
    }
    return 0;
}