C++博客-Programming Every Day-随笔分类-算法笔记

poj 1611 The Suspects

田兵 — Thu, 26 Aug 2010 12:02:00 GMT

Problem: 1611		User: hehexiaobai
Memory: 364K		Time: 454MS
Language: C++		Result: Accepted

又是一个并查集。
一个人是SARS疑似病例，他所在的整个group都是疑似病例，第0(1)个是疑似病例，求有多少个疑似病例。

#include<iostream>
using namespace std;
const int MAX=30001;
int fa[MAX];

int find(int x)
{
    return fa[x]==x?x:find(fa[x]);
}

void Union(int x, int y)
{
     fa[find(x)]=find(y);
}
int main()
{
    int n,m;
    for(; ;)
    { 
             cin>>n>>m;
             if( n==0&&m==0)break;
             for(int i=1; i<=n; i++)
                     fa[i]=i;
             
             int k,stu;
             for(int i=1; i<=m; i++)
             {
                     cin>>k;
                     if(k>0)
                     {
                        int temp,ttemp;
                        cin>>temp;
                        ++temp;
                        fa[temp]=find(temp);
                        for(int j=1; j<k; j++)
                                {
                                     cin>>ttemp;
                                     ++ttemp;
                                     fa[find(temp)]=find(ttemp);//Union(temp,ttemp);
                                     //如果没有找到根节点合并的话可能会断掉，要整个都和另一个合并 
                                }
                     }
             }
             
             int father=find(1),ans=1;
             for(int i=2; i<=n; i++)
                     if(find(i)==father)ans++;
             cout<<ans<<endl;      
               
    }
    
    system("pause");    
    return 0;
}

田兵 2010-08-26 20:02 发表评论

poj 2524 Ubiquitous Religions 【并查集】

田兵 — Thu, 26 Aug 2010 11:20:00 GMT

Ubiquitous Religions

Time Limit: 5000MS		Memory Limit: 65536K
Total Submissions: 12445		Accepted: 5900

Description

There are so many different religions in the world today that it is difficult to keep track of them all. You are interested in finding out how many different religions students in your university believe in.

You know that there are n students in your university (0 < n <= 50000). It is infeasible for you to ask every student their religious beliefs. Furthermore, many students are not comfortable expressing their beliefs. One way to avoid these problems is to ask m (0 <= m <= n(n-1)/2) pairs of students and ask them whether they believe in the same religion (e.g. they may know if they both attend the same church). From this data, you may not know what each person believes in, but you can get an idea of the upper bound of how many different religions can be possibly represented on campus. You may assume that each student subscribes to at most one religion.

Input

The input consists of a number of cases. Each case starts with a line specifying the integers n and m. The next m lines each consists of two integers i and j, specifying that students i and j believe in the same religion. The students are numbered 1 to n. The end of input is specified by a line in which n = m = 0.

Output

For each test case, print on a single line the case number (starting with 1) followed by the maximum number of different religions that the students in the university believe in.

Sample Input

Sample Output

Case 1: 1
Case 2: 7

第一个并查集程序，最小生成树不算。

n个点，给你m条边，求最大能有多少个连通分量。

#include<iostream>
using namespace std;
const int MAX=50001;
int fa[MAX];

int find(int x)
{
    return fa[x]==x?x:find(fa[x]);
}

void Union(int x, int y)
{
     fa[find(x)]=find(y);
}
int main()
{
    int n,m;
    for(int tt=1; ; tt++)
    { 
              cin>>n>>m;
             if( n==0&&m==0)break;
             
             for(int i=1; i<=n; i++)
                     fa[i]=i; 
                     
             int max=n;              
             for(int i=1,s,t; i<=m; i++)
                     {
                         cin>>s>>t;
                         if(find(s)!=find(t))max=max-1;
                         Union(s,t);              
                     }
                     
             cout<<"Case "<<tt<<':'<<' '<<max<<endl;
             
    }
    
    system("pause");    
    return 0;
}

田兵 2010-08-26 19:20 发表评论

poj 3273 Monthly Expense 【二分】

田兵 — Wed, 25 Aug 2010 01:19:00 GMT

把n个数分成m分，数字的顺序不能变，使每份的和的最大值最小。

第一次用二分，觉得很强大，参考牛人的。

#include<iostream>
#include<algorithm>
#include <numeric>
#include<stdio.h>
using namespace std;
int digit[100005];
int main()
{
   
    int n, m, i, maxv=0, minv=0;
    cin>>n>>m;
    for(i=1; i<=n; i++)
        scanf("%d",&digit[i]);//cin>>digit[i];
    
    maxv=accumulate(digit+1,digit+1+n,0);
    minv= *max_element(digit+1,digit+1+n);
    
    int midv;
    while( minv < maxv )
    {
        
        midv = ( minv + maxv )/2;
        int k = 0 , sum = 0 ;
        
        for( i=1; i <= n; i++ )
        {
            sum += digit[i];
            if(sum > midv)
            {
                sum = digit[i];
                k ++;
            }
        }

        if( k < m ) maxv = midv;
        else minv = midv + 1;

    }
     cout << maxv << endl;

    return 0;
}

田兵 2010-08-25 09:19 发表评论

Anagrams by Stack 【集训比赛用题】

田兵 — Sat, 21 Aug 2010 10:40:00 GMT

Anagrams by Stack

Time Limit: 1000 ms Memory Limit: 64 MB
Total Submission: 10 Accepted: 1

Description

How can anagrams result from sequences of stack operations? There are two sequences of stack operators which can convert TROT to TORT:

[
i i i i o o o o
i o i i o o i o
]

where i stands for Push and o stands for Pop. Your program should, given pairs of words produce sequences of stack operations which convert the first word to the second.

Input

The input will consist of several lines of input. The first line of each pair of input lines is to be considered as a source word (which does not include the end-of-line character). The second line (again, not including the end-of-line character) of each pair is a target word. The end of input is marked by end of file.

Output

For each input pair, your program should produce a sorted list of valid sequences of i and o which produce the target word from the source word. Each list should be delimited by

[
]

and the sequences should be printed in "dictionary order". Within each sequence, each i and o is followed by a single space and each sequence is terminated by a new line.
Process
A stack is a data storage and retrieval structure permitting two operations:

Push - to insert an item and
Pop - to retrieve the most recently pushed item
We will use the symbol i (in) for push and o (out) for pop operations for an initially empty stack of characters. Given an input word, some sequences of push and pop operations are valid in that every character of the word is both pushed and popped, and furthermore, no attempt is ever made to pop the empty stack. For example, if the word FOO is input, then the sequence:

i i o i o o is valid, but
i i o is not (it's too short), neither is
i i o o o i (there's an illegal pop of an empty stack)

Valid sequences yield rearrangements of the letters in an input word. For example, the input word FOO and the sequence i i o i o o produce the anagram OOF. So also would the sequence i i i o o o. You are to write a program to input pairs of words and output all the valid sequences of i and o which will produce the second member of each pair from the first.

Sample Input

madam
adamm
bahama
bahama
long
short
eric
rice

Sample Output

[[EOL]
i i i i o o o i o o [EOL]
i i i i o o o o i o [EOL]
i i o i o i o i o o [EOL]
i i o i o i o o i o [EOL]
][EOL]
[[EOL]
i o i i i o o i i o o o [EOL]
i o i i i o o o i o i o [EOL]
i o i o i o i i i o o o [EOL]
i o i o i o i o i o i o [EOL]
][EOL]
[[EOL]
][EOL]
[[EOL]
i i o i o i o o [EOL]
][EOL][EOF]

这题是zoj的题目，题目意思就是给你一个源串和一个目标串，输出所有利用栈将源串转化成目标串的方案。

i 代表入栈， o代表出栈(也就是输出)。

ZOJ是0ms轻易过了，可是在自己的我们学校的OJ就一直TLE。

搜索题，输出的 i o串的长度为源串长len1的两边，因为每个都有进去再出去。
有几个剪枝的地方：
1，cnti代码输出i的次数，肯定小于len1，即len/2，如果大于则返回。
2，cnto同上。
3，如果cnti
我这是到了最后才用judge判断是否可行，如果在过程中就判断的话，应该会更快。

原始代码：

#include<iostream>
#include<string>
#include<stack>
#include<queue>
#include<algorithm>
#include<stdio.h>
using namespace std;
int ans[1005],len;
char s1[100],s2[100];
string source ,target;
bool judge()
{
     stack<char> s;
     int in=-1,out=-1;
     for(int i=1; i<=len ; i++)
     {
             if(ans[i]==1)//in
             {
                              in++;
                          if(in==source.size())return false;
                          else s.push(source[in]);
                          
             }
             else //out
             {
                 out++;  
                 if(out==source.size())return false;
                 if(s.empty())return false;
                 else if( s.top()!=target[out])return false;
                 s.pop();
             }
     }
     return true;
}

void dfs(int i,int cnti, int cnto)
{
     if( (cnti>len/2)||(cnto>len/2) )return ;
     if(cnti<cnto)return ;
     //cout<
     if(i==len+1)
     {
                 if(judge())
                 {
                          
                          for(int i=1; i<=len; i++)
                                  if(ans[i]==1)cout<<"i ";
                                  else cout<<"o ";
                          cout<<endl;
                 }
               return ;
     }
     ans[i]=1;  //i
     dfs(i+1,cnti+1,cnto);
     ans[i]=2;  //o
     dfs(i+1,cnti,cnto+1);
}

int main()
{
  
    while(cin>>source>>target)
    {
           string s1=source,s2=target;
           if(s1.size()!=s2.size()){cout<<'['<<endl; cout<<']'<<endl; continue; }
           sort(s1.begin(),s1.end());
           sort(s2.begin(),s2.end());
           if(s1!=s2){cout<<'['<<endl; cout<<']'<<endl; continue; }
           len=source.size()*2;     
           cout<<'['<<endl;
           dfs(1,0,0);             
           cout<<']'<<endl;
    }
    system("pause");
    return 0;
}

后来几乎把所有C++的东西改为C后才100ms+过的。

尤其是把STL里面的 stack 直接用数组模拟。

#include<iostream>
#include<stack>
#include<cstring>
#include<algorithm>
#include<stdio.h>
using namespace std;
int ans[1005],len,len1,len2;
char source[100],target[100];
char s1[100],s2[100];
int s[1000];
bool judge()
{
     int top=0;
     int in=-1,out=-1;
     for(int i=1; i<=len ; i++)
     {
             if(ans[i]==1)//in
             {
                          in++;
                          if(in==len1)return false;
                          else s[++top]=source[in];
                          
             }
             else //out
             {
                 out++;  
                 if(out==len1)return false;
                 if(top==0)return false;
                 else if( s[top]!=target[out])return false;
                 top--;
             }
     }
     return true;
}

void dfs(int i,int cnti, int cnto)
{
     if( (cnti>len/2)||(cnto>len/2) )return ;
     if(cnti<cnto)return ;
     //cout<
     if(i==len+1)
     {
                 if(judge())
                 {
                          
                          for(int i=1; i<=len; i++)
                                  if(ans[i]==1)printf("i ");//cout<<"i ";
                                  else printf("o ");//cout<<"o ";
                          printf("\n");//cout<
                 }
               return ;
     }
     ans[i]=1;  //i
     dfs(i+1,cnti+1,cnto);
     ans[i]=2;  //o
     dfs(i+1,cnti,cnto+1);
}

int main()
{
  
    while(scanf("%s %s",source,target)!=EOF)
    {
           len1=strlen(source),len2=strlen(target);
           if(len1!=len2){ cout<<'['<<endl; cout<<']'<<endl; continue; }
           for(int i=0; i<len1; i++)
           {
                   s1[i]=source[i];
                   s2[i]=target[i];
           }
           
           sort(s1,s1+len1);
           sort(s2,s2+len1);
           if(strcmp(s1,s2)!=0){cout<<'['<<endl; cout<<']'<<endl; continue; }
           len=len1*2;     
           cout<<'['<<endl;
           dfs(1,0,0);             
           cout<<']'<<endl;
    }
    system("pause");
    return 0;
}

田兵 2010-08-21 18:40 发表评论

滑雪寄存器数据转换（POJ上的位操作）

田兵 — Sat, 14 Aug 2010 12:41:00 GMT

滑雪

Time Limit: 1000 ms Memory Limit: 64 MB
Total Submission: 84 Accepted: 20

Description

Michael喜欢滑雪百这并不奇怪，因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael想知道载一个区域中最长底滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。下面是一个例子

1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度减小。在上面的例子中，一条可滑行的滑坡为24-17-16-1。当然25-24-23-...-3-2-1更长。事实上，这是最长的一条。

Input

输入的第一行表示区域的行数R和列数C(1 <= R,C <= 100)。下面是R行，每行有C个整数，代表高度h，0<=h<=10000。输入0 0结束。

Output

输出最长区域的长度。

Sample Input

5 5
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

Sample Output

25[EOL][EOF]

Source

SHTSC 2002

第六次集训赛

原来对每个点求一次最短路径超时了。

原来这题是记忆化搜索，DP的思想，DP真的是一点都不知道。

记忆化搜索可以避免重复的子问题，这也应该是它比较快的原因吧。

#include<iostream>
#include<string.h>
using namespace std;
int G[105][105]={0},d[105][105]={0};
int mmax=0,ans=0;
int R,C;
int dx[4]={0,1, 0,-1},
    dy[4]={1,0,-1, 0};
int dfs(int i, int j)
{
      if(d[i][j]>0)return d[i][j];
      int tx,ty;
      int max=0;
      for(int k=0; k<=3; k++)
      {
              tx=i+dx[k]; ty=j+dy[k];
              if(tx>=1&&tx<=R&&ty>=1&&ty<=C&&G[i][j]>G[tx][ty])
                      {
                            int t;
                            if(max< (t=dfs(tx,ty)) )
                                      max=t;
                      }
      }
      return d[i][j]=max+1;
}

void print()
{
     for(int i=1; i<=R; i++,cout<<endl)
     for(int j=1; j<=C; j++)
             cout<<d[i][j]<<' ';
}
int main()
{
    
    while(cin>>R>>C,R||C)
    {
               ans=0;
               memset(G,0,sizeof G);
               for(int i=1; i<=R; i++)
               for(int j=1; j<=C; j++)
                      cin>>G[i][j]; 
               int ans=0;
               memset(d,0,sizeof d); 
               for(int i=1; i<=R; i++)
               for(int j=1; j<=C; j++)
               {       
                       
                       dfs(i,j);
               }
               
               for(int i=1; i<=R; i++)
               for(int j=1; j<=C; j++)
               if(ans<d[i][j])ans=d[i][j];
               cout<<ans<<endl;
               //print();
    }
    
    system("pause");
    return 0;
}

寄存器数据转换

Time Limit: 1000 ms Memory Limit: 64 MB
Total Submission: 79 Accepted: 20

Description

假设你工作在一个32位的机器上，你需要将某一个外设寄存器的第X位设置成0(最低位为第0位，最高位为第31位)，将第Y位开始的连续三位设置成110（从高位到低位的顺序），而其他位保持不变。对给定的寄存器值R，及X，Y，编程计算更改后的寄存器值R。

Input

第一行为整数T<1000，表示要输入的数据数
每一行，包括R,X,Y，以逗号","分隔，R为16进制表示的32位整数(小写字母)，X,Y在0-31之间且Y>=3，(Y-X)的绝对值>=3，保证两次置位不会重合

Output

每组数据占一行，显示更改后的寄存器值R（16进制输出），不要输出前置0

Sample Input

1
12345678,0,3

Sample Output

1234567c[EOL][EOF]

用位操作这么简单，我还用笨方法做。……

#include<stdio.h>
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
    int r,x,y,r1;
    scanf("%x,%d,%d",&r,&x,&y);
    r1=1; r1<<=x; r1=~r1; r=r&r1;
    r1=1; r1<<=y; r|=r1;
    r1=1; r1<<=(y-1); r|=r1;
    r1=1; r1<<=(y-2); r1=~r1; r=r&r1;
    printf("%x\n",r);
    
    }
    return 0;
}

田兵 2010-08-14 20:41 发表评论

USACO chapter 3 section 2 Sweet Butter

田兵 — Sun, 08 Aug 2010 01:20:00 GMT

摘要: 做了一题，开心，冒一下泡：题目大意：有一些草原（1，……，p个），告诉你n个奶牛的在哪个草原，Famer John 会在其中一个草原放一块糖，让所有的奶牛去舔（提高奶的质量^-^），要求的就是把糖放在哪个草原使所有的奶牛到那的路程和最短。（当然奶牛都是拣最短的路走）。第一种超时思路：Floyd算法求出任意两个草原间的距离，枚举所有草原，取所... 阅读全文

田兵 2010-08-08 09:20 发表评论

POJ 2709 Painter 贪心

田兵 — Sat, 07 Aug 2010 08:56:00 GMT

这题比较犀利，特别的地方是在配灰色的时候。

用judge[]存储减去对应颜色后剩余的体积，用这部分配灰色。当然judge中的每一项都有大于0

配法：每排一次序配1ml，保证这1ml是由体积最多的三种颜料配成。

最初的时候是排序，然后一下配最大的三个当中最小的那个的体积，这是不够贪的。

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
int color[13]={0};
int judge[13]={0};
int deal(int n)
{
     int ans=0,t;
     sort(judge+1, judge+1+n);
     while(judge[n]&&judge[n-1]&&judge[n-2])
     {
             ans++;
             judge[n]--;
             judge[n-1]--;
             judge[n-2]--;
             sort(judge+1, judge+1+n);
     }
     return ans;
}

int main()
{
    int n,i;
    while(cin>>n,n)
    {
            int t=0 ,num; 
            bool f=true;
            for(i=1; i<=n; i++)
                     cin>>color[i];
            cin>>num;
            for(t=0; t<=1000; t++)
            {       
                     f=true;
                     for(int j=1; j<=n; j++)
                            {
                                   judge[j]=50*t;
                                   judge[j]-=color[j];
                                   if(judge[j]<0)f=false; 
                            } 
                     if(f==true)
                     {
                        int ans=deal(n);
                        if( ans>=num) { cout<<t<<endl; break; }      
                     }
            }
                  
    }

    system("pause");
    return 0;
}

田兵 2010-08-07 16:56 发表评论

背包问题【转】

田兵 — Tue, 03 Aug 2010 12:40:00 GMT

P01：01背包问题

题目：有N件物品和一个容量为V的背包。第i件物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

基本思路：

这是最基础的背包问题，特点是：每种物品仅有一件，可以选择放或不放。

用子问题定义状态：即f[i][v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值。则其状态转移方程便是：f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]+w[i]}。

这个方程非常重要，基本上所有跟背包相关的问题的方程都是由它衍生出来的。所以有必要将它详细解释一下：“将前i件物品放入容量为v的背包中”这个子问题，若只考虑第i件物品的策略（放或不放），那么就可以转化为一个只牵扯前i-1件物品的问题。如果不放第i件物品，那么问题就转化为“前i-1件物品放入容量为v的背包中”；如果放第i件物品，那么问题就转化为“前i-1件物品放入剩下的容量为v-c[i]的背包中”，此时能获得的最大价值就是f [i-1][v-c[i]]再加上通过放入第i件物品获得的价值w[i]。

注意f[i][v]有意义当且仅当存在一个前i件物品的子集，其费用总和为v。所以按照这个方程递推完毕后，最终的答案并不一定是f[N] [V]，而是f[N][0..V]的最大值。如果将状态的定义中的“恰”字去掉，在转移方程中就要再加入一项f[i][v-1]，这样就可以保证f[N] [V]就是最后的答案。至于为什么这样就可以，由你自己来体会了。

优化空间复杂度：

以上方法的时间和空间复杂度均为O(N*V)，其中时间复杂度基本已经不能再优化了，但空间复杂度却可以优化到O(V)。

先考虑上面讲的基本思路如何实现，肯定是有一个主循环i=1..N，每次算出来二维数组f[i][0..V]的所有值。那么，如果只用一个数组f [0..V]，能不能保证第i次循环结束后f[v]中表示的就是我们定义的状态f[i][v]呢？f[i][v]是由f[i-1][v]和f[i-1][v-c[i]]两个子问题递推而来，能否保证在推f[i][v]时（也即在第i次主循环中推f[v]时）能够得到f[i-1][v]和f[i-1][v -c[i]]的值呢？事实上，这要求在每次主循环中我们以v=V..0的顺序推f[v]，这样才能保证推f[v]时f[v-c[i]]保存的是状态f[i -1][v-c[i]]的值。伪代码如下：

for i=1..N

for v=V..0

f[v]=max{f[v],f[v-c[i]]+w[i]};

其中的f[v]=max{f[v],f[v-c[i]]}一句恰就相当于我们的转移方程f[i][v]=max{f[i-1][v],f[i- 1][v-c[i]]}，因为现在的f[v-c[i]]就相当于原来的f[i-1][v-c[i]]。

如果将v的循环顺序从上面的逆序改成顺序的话，那么则成了f[i][v]由f[i][v-c[i]]推知，与本题意不符，但它却是另一个重要的背包问题P02最简捷的解决方案，故学习只用一维数组解01背包问题是十分必要的。

总结：

01背包问题是最基本的背包问题，它包含了背包问题中设计状态、方程的最基本思想，另外，别的类型的背包问题往往也可以转换成01背包问题求解。故一定要仔细体会上面基本思路的得出方法，状态转移方程的意义，以及最后怎样优化的空间复杂度。

P02：完全背包问题

题目：有N种物品和一个容量为V的背包，每种物品都有无限件可用。第i种物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

基本思路：

这个问题非常类似于01背包问题，所不同的是每种物品有无限件。也就是从每种物品的角度考虑，与它相关的策略已并非取或不取两种，而是有取0件、取1件、取2件……等很多种。如果仍然按照解01背包时的思路，令f[i][v]表示前i种物品恰放入一个容量为v的背包的最大权值。仍然可以按照每种物品不同的策略写出状态转移方程，像这样：f[i][v]=max{f[i-1][v-k*c[i]]+k*w[i]|0<=k*c[i]<= v}。这跟01背包问题一样有O(N*V)个状态需要求解，但求解每个状态的时间则不是常数了，求解状态f[i][v]的时间是O(v/c[i])，总的复杂度是超过O(VN)的。

将01背包问题的基本思路加以改进，得到了这样一个清晰的方法。这说明01背包问题的方程的确是很重要，可以推及其它类型的背包问题。但我们还是试图改进这个复杂度。

一个简单有效的优化：

完全背包问题有一个很简单有效的优化，是这样的：若两件物品i、j满足c[i]<=c[j]且w[i]>=w[j]，则将物品j去掉，不用考虑。这个优化的正确性显然：任何情况下都可将价值小费用高得j换成物美价廉的i，得到至少不会更差的方案。对于随机生成的数据，这个方法往往会大大减少物品的件数，从而加快速度。然而这个并不能改善最坏情况的复杂度，因为有可能特别设计的数据可以一件物品也去不掉。

转化为01背包问题求解：

既然01背包问题是最基本的背包问题，那么我们可以考虑把完全背包问题转化为01背包问题来解。最简单的想法是，考虑到第i种物品最多选V/c[i]件，于是可以把第i种物品转化为V/c[i]件费用及价值均不变的物品，然后求解这个01背包问题。这样完全没有改进基本思路的时间复杂度，但这毕竟给了我们将完全背包问题转化为01背包问题的思路：将一种物品拆成多件物品。

更高效的转化方法是：

把第i种物品拆成费用为c[i]*2^k、价值为w[i]*2^k的若干件物品，其中k满足c[i]*2^k

O(VN)的算法：这个算法使用一维数组，先看伪代码： <以class为例> for i=1..N for v=0..V f[v]=max{f[v],f[v-c[i]]+w[i]};

你会发现，这个伪代码与P01的伪代码只有v的循环次序不同而已。为什么这样一改就可行呢？首先想想为什么P01中要按照v=V..0的逆序来循环。这是因为要保证第i次循环中的状态f[i][v]是由状态f[i-1][v-c[i]]递推而来。换句话说，这正是为了保证每件物品只选一次，保证在考虑“选入第i件物品”这件策略时，依据的是一个绝无已经选入第i件物品的子结果f[i-1][v-c[i]]。而现在完全背包的特点恰是每种物品可选无限件，所以在考虑“加选一件第i种物品”这种策略时，却正需要一个可能已选入第i种物品的子结果f[i][v-c[i]]，所以就可以并且必须采用v= 0..V的顺序循环。这就是这个简单的程序为何成立的道理。

这个算法也可以以另外的思路得出。例如，基本思路中的状态转移方程可以等价地变形成这种形式：f[i][v]=max{f[i-1][v],f[i][v-c[i]]+w[i]}，将这个方程用一维数组实现，便得到了上面的伪代码。

总结：

完全背包问题也是一个相当基础的背包问题，它有两个状态转移方程，分别在“基本思路”以及“O(VN)的算法“的小节中给出。希望你能够对这两个状态转移方程都仔细地体会，不仅记住，也要弄明白它们是怎么得出来的，最好能够自己想一种得到这些方程的方法。事实上，对每一道动态规划题目都思考其方程的意义以及如何得来，是加深对动态规划的理解、提高动态规划功力的好方法。

P03：多重背包问题

题目：有N种物品和一个容量为V的背包。第i种物品最多有n[i]件可用，每件费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

基本算法：

这题目和完全背包问题很类似。基本的方程只需将完全背包问题的方程略微一改即可，因为对于第i种物品有n[i]+1种策略：取0件，取1件……取 n[i]件。令f[i][v]表示前i种物品恰放入一个容量为v的背包的最大权值，则：f[i][v]=max{f[i-1][v-k*c[i]]+ k*w[i]|0<=k<=n[i]}。复杂度是O(V*∑n[i])。

转化为01背包问题：

另一种好想好写的基本方法是转化为01背包求解：把第i种物品换成n[i]件01背包中的物品，则得到了物品数为∑n[i]的01背包问题，直接求解，复杂度仍然是O(V*∑n[i])。

但是我们期望将它转化为01背包问题之后能够像完全背包一样降低复杂度。仍然考虑二进制的思想，我们考虑把第i种物品换成若干件物品，使得原问题中第i种物品可取的每种策略——取0..n[i]件——均能等价于取若干件代换以后的物品。另外，取超过n[i]件的策略必不能出现。

方法是：将第i种物品分成若干件物品，其中每件物品有一个系数，这件物品的费用和价值均是原来的费用和价值乘以这个系数。使这些系数分别为 1,2,4,...,2^(k-1),n[i]-2^k+1，且k是满足n[i]-2^k+1>0的最大整数。例如，如果n[i]为13，就将这种物品分成系数分别为1,2,4,6的四件物品。

分成的这几件物品的系数和为n[i]，表明不可能取多于n[i]件的第i种物品。另外这种方法也能保证对于0..n[i]间的每一个整数，均可以用若干个系数的和表示，这个证明可以分0..2^k-1和2^k..n[i]两段来分别讨论得出，并不难，希望你自己思考尝试一下。

这样就将第i种物品分成了O(log n[i])种物品，将原问题转化为了复杂度为O(V*∑log n[i])的01背包问题，是很大的改进。

O(VN)的算法：

多重背包问题同样有O(VN)的算法。这个算法基于基本算法的状态转移方程，但应用单调队列的方法使每个状态的值可以以均摊O(1)的时间求解。由于用单调队列优化的DP已超出了NOIP的范围，故本文不再展开讲解。我最初了解到这个方法是在楼天成的“男人八题”幻灯片上。

小结：

这里我们看到了将一个算法的复杂度由O(V*∑n[i])改进到O(V*∑log n[i])的过程，还知道了存在应用超出NOIP范围的知识的O(VN)算法。希望你特别注意“拆分物品”的思想和方法，自己证明一下它的正确性，并用尽量简洁的程序来实现。

P04：混合三种背包问题

问题：

如果将P01、P02、P03混合起来。也就是说，有的物品只可以取一次（01背包），有的物品可以取无限次（完全背包），有的物品可以取的次数有一个上限（多重背包）。应该怎么求解呢？

01背包与完全背包的混合：

考虑到在P01和P02中最后给出的伪代码只有一处不同，故如果只有两类物品：一类物品只能取一次，另一类物品可以取无限次，那么只需在对每个物品应用转移方程时，根据物品的类别选用顺序或逆序的循环即可，复杂度是O(VN)。伪代码如下：

for i=1..N

if 第i件物品是01背包

for v=V..0

f[v]=max{f[v],f[v-c[i]]+w[i]};

else if 第i件物品是完全背包

for v=0..V

f[v]=max{f[v],f[v-c[i]]+w[i]};

再加上多重背包：

如果再加上有的物品最多可以取有限次，那么原则上也可以给出O(VN)的解法：遇到多重背包类型的物品用单调队列解即可。但如果不考虑超过NOIP范围的算法的话，用P03中将每个这类物品分成O(log n[i])个01背包的物品的方法也已经很优了。

小结：

有人说，困难的题目都是由简单的题目叠加而来的。这句话是否公理暂且存之不论，但它在本讲中已经得到了充分的体现。本来01背包、完全背包、多重背包都不是什么难题，但将它们简单地组合起来以后就得到了这样一道一定能吓倒不少人的题目。但只要基础扎实，领会三种基本背包问题的思想，就可以做到把困难的题目拆分成简单的题目来解决。

P05：二维费用的背包问题

问题：

二维费用的背包问题是指：对于每件物品，具有两种不同的费用；选择这件物品必须同时付出这两种代价；对于每种代价都有一个可付出的最大值（背包容量）。问怎样选择物品可以得到最大的价值。设这两种代价分别为代价1和代价2，第i件物品所需的两种代价分别为a[i]和b[i]。两种代价可付出的最大值（两种背包容量）分别为V和U。物品的价值为w[i]。

算法：

费用加了一维，只需状态也加一维即可。设f[i][v][u]表示前i件物品付出两种代价分别为v和u时可获得的最大价值。状态转移方程就是：f [i][v][u]=max{f[i-1][v][u],f[i-1][v-a[i]][u-b[i]]+w[i]}。如前述方法，可以只使用二维的数组：当每件物品只可以取一次时变量v和u采用顺序的循环，当物品有如完全背包问题时采用逆序的循环。当物品有如多重背包问题时拆分物品。

物品总个数的限制：

有时，“二维费用”的条件是以这样一种隐含的方式给出的：最多只能取M件物品。这事实上相当于每件物品多了一种“件数”的费用，每个物品的件数费用均为1，可以付出的最大件数费用为M。换句话说，设f[v][m]表示付出费用v、最多选m件时可得到的最大价值，则根据物品的类型（01、完全、多重）用不同的方法循环更新，最后在f[0..V][0..M]范围内寻找答案。

另外，如果要求“恰取M件物品”，则在f[0..V][M]范围内寻找答案。

小结：

事实上，当发现由熟悉的动态规划题目变形得来的题目时，在原来的状态中加一纬以满足新的限制是一种比较通用的方法。希望你能从本讲中初步体会到这种方法。

田兵 2010-08-03 20:40 发表评论

快速排序

田兵 — Tue, 15 Jun 2010 02:57:00 GMT

简单实现的快速排序：
最优解：每次选取的是中间位置的元素，O(nlogn)
最差解：每次选的是最大的或最小的元素，这样每次只能排一个O(n^2)

#include<iostream>
#include<stdlib.h>
using namespace std;
const int arraySize=10;
int array[arraySize]={2,5,8,3,6,9,1,4,7,0};
void swap(int array[],int i,int j)
{
     int temp=array[i];
         array[i]=array[j];
         array[j]=temp;
}

void quicksort(int array[],int n)
{


     int i,last;
     if(n<=1) return ;
     swap(array,0,rand()%n);  //随即选取一个点，作为比较元素
     last=0;
     for(i=1 ;i < n; i++ )
       if(array[i] < array[0] )
         swap(array,++last,i);
     swap(array,last,0);                //把用于比较的元素放入合适位置
     quicksort(array,last);
     quicksort(array+last+1,n-last-1);
}

int main()
{
   quicksort(array,10);
   for(int i=0; i<arraySize; i++)
    cout<<array[i]<<' ';
   cout<<endl;

   system("pause");
    return 0;
}

田兵 2010-06-15 10:57 发表评论

PKU 2251 用DFS TLE了 BFS AC了

田兵 — Fri, 28 May 2010 13:50:00 GMT

Dungeon Master

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 6561		Accepted: 2610

Description

You are trapped in a 3D dungeon and need to find the quickest way out! The dungeon is composed of unit cubes which may or may not be filled with rock. It takes one minute to move one unit north, south, east, west, up or down. You cannot move diagonally and the maze is surrounded by solid rock on all sides.

Is an escape possible? If yes, how long will it take?

Input

The input consists of a number of dungeons. Each dungeon description starts with a line containing three integers L, R and C (all limited to 30 in size).
L is the number of levels making up the dungeon.
R and C are the number of rows and columns making up the plan of each level.
Then there will follow L blocks of R lines each containing C characters. Each character describes one cell of the dungeon. A cell full of rock is indicated by a '#' and empty cells are represented by a '.'. Your starting position is indicated by 'S' and the exit by the letter 'E'. There's a single blank line after each level. Input is terminated by three zeroes for L, R and C.

Output

Each maze generates one line of output. If it is possible to reach the exit, print a line of the form

Escaped in x minute(s).

where x is replaced by the shortest time it takes to escape.
If it is not possible to escape, print the line

Trapped!

Sample Input

3 4 5
S....
.###.
.##..
###.#
#####
#####
##.##
##...
#####
#####
#.###
####E
1 3 3
S##
#E#
###
0 0 0

Sample Output

Escaped in 11 minute(s).
Trapped!

三维迷宫问题
据说要用BFS，范围30 ，我以为DFS能搞定的，为什么会超时呢？？？？

1#include
2#include
3using namespace std;
4char G[35][35][35];
5bool g[35][35][35];
6void dfs(int l,int r,int c)
7{
8     if(G[l][r][c]==0||G[l][r][c]=='#')return ;
9     if((G[l+1][r][c]=='.'||G[l+1][r][c]>G[l][r][c])&&G[l+1][r][c]!=0&&G[l+1][r][c]!='#') { G[l+1][r][c]=G[l][r][c]+1;g[l+1][r][c]=1;dfs(l+1,r,c);}
10     if((G[l][r-1][c]=='.'||G[l][r-1][c]>G[l][r][c])&&G[l][r-1][c]!=0&&G[l][r-1][c]!='#') { G[l][r-1][c]=G[l][r][c]+1;g[l][r-1][c]=1;dfs(l,r-1,c);}
11     if((G[l][r+1][c]=='.'||G[l][r+1][c]>G[l][r][c])&&G[l][r+1][c]!=0&&G[l][r+1][c]!='#') { G[l][r+1][c]=G[l][r][c]+1;g[l][r+1][c]=1;dfs(l,r+1,c);}
12     if((G[l][r][c-1]=='.'||G[l][r][c-1]>G[l][r][c])&&G[l][r][c-1]!=0&&G[l][r][c-1]!='#') { G[l][r][c-1]=G[l][r][c]+1;g[l][r][c-1]=1;dfs(l,r,c-1);}
13     if((G[l][r][c+1]=='.'||G[l][r][c+1]>G[l][r][c])&&G[l][r][c+1]!=0&&G[l][r][c+1]!='#') { G[l][r][c+1]=G[l][r][c]+1;g[l][r][c+1]=1;dfs(l,r,c+1);}
14     if((G[l-1][r][c]=='.'||G[l-1][r][c]>G[l][r][c])&&G[l-1][r][c]!=0&&G[l-1][r][c]!='#') { G[l-1][r][c]=G[l][r][c]+1;g[l-1][r][c]=1;dfs(l-1,r,c);}
15}
16
17int main()
18{
19     int i,j,k,l,r,c,sl,sr,sc,el,er,ec;  //起点，终点
20     while(cin>>l>>r>>c,l||r||c)
21     {
22        memset(G,0,sizeof (G));
23        memset(g,0,sizeof (g));
24        for(i=1; i<=l ;i++)
25        for(j=1; j<=r; j++)
26        for(k=1; k<=c; k++)
27        {
28          cin>>G[i][j][k];
29          if(G[i][j][k]=='S')
30          { sl=i; sr=j; sc=j; G[i][j][k]=1; g[i][j][k]=1; }
31          else if(G[i][j][k]=='E')
32          {el=i; er=j; ec=k; G[i][j][k]=127; }
33        }
34
35        dfs(sl,sr,sc);
36      /**//*  for(i=1; i<=l ; i++,cout<37        for(j=1; j<=r; j++,cout<38        for(k=1; k<=c; k++)
39        cout<<(int)G[i][j][k]<<" ";
40        for(i=1; i<=l ; i++,cout<41        for(j=1; j<=r; j++,cout<42        for(k=1; k<=c; k++)
43        cout<<(int)g[i][j][k]<<" ";
44        */if(g[el][er][ec]==0)cout<<"Trapped!"<45        else cout<<"Escaped in "<46     }
47    // system("pause");
48    return 0;
49}

写个BFS终于过了，只要在平面的迷宫基础上在垂直方向往上，往下都搜两次就可以了

1 #include<iostream>
2 #include<string.h>
3 #include<queue>
4 using namespace std;
5 char G[35][35][35];
6 int cnt[35][35][35];
7 struct type
8 { int l,r,c; };
9
10 int main()
11 {
12     int l,c,r,sl,sc,sr,el,ec,er,i,j,k;
13     void bfs(int sl,int sr,int sc);
14     while(cin>>l>>r>>c,l||c||r)
15     {
16       memset(G,0,sizeof (G));
17       memset(cnt,0,sizeof (cnt));
18       for(i=1; i<=l; i++)
19       for(j=1; j<=r; j++)
20       for(k=1; k<=c; k++)
21       {
22         cin>>G[i][j][k];
23         if(G[i][j][k]=='S'){sl=i; sr=j; sc=k; }
24         else if(G[i][j][k]=='E'){el=i; er=j; ec=k; }
25       }
26
27       bfs(sl,sr,sc);
28    //  for(i=1; i<=l; i++,cout<29     // for(j=1; j<=r; j++,cout<30      //for(k=1; k<=c; k++)
31      //cout<
32
33     if(el==sl&&er==sr&&ec==sc)cout<<"Escaped in "<<0<<" minute(s). "<<endl;
34     else if(cnt[el][er][ec]>0)cout<<"Escaped in "<<cnt[el][er][ec]<<" minute(s). "<<endl;
35     else cout<<"Trapped! "<<endl;
36     }
37    // system("pause");
38     return 0;
39 }
40
41 bool valid(int l,int r,int c)
42 {
43   return (G[l][r][c]=='.'||G[l][r][c]=='E');
44 }
45
46 void bfs(int sl,int sr, int sc)
47 {
48   queue<struct type> q;
49   struct type tem; tem.l=sl; tem.r=sr; tem.c=sc;
50   q.push(tem);
51   while(q.size())
52   {
53     tem=q.front(); q.pop();
54     int l=tem.l,r=tem.r,c=tem.c;
55     if(valid(l,r+1,c)&&cnt[l][r+1][c]==0){cnt[l][r+1][c]=cnt[l][r][c]+1;tem.l=l; tem.r=r+1; tem.c=c; q.push(tem); }
56     if(valid(l,r-1,c)&&cnt[l][r-1][c]==0){cnt[l][r-1][c]=cnt[l][r][c]+1;tem.l=l; tem.r=r-1; tem.c=c; q.push(tem); }
57     if(valid(l,r,c+1)&&cnt[l][r][c+1]==0){cnt[l][r][c+1]=cnt[l][r][c]+1;tem.l=l; tem.r=r; tem.c=c+1; q.push(tem); }
58     if(valid(l,r,c-1)&&cnt[l][r][c-1]==0){cnt[l][r][c-1]=cnt[l][r][c]+1;tem.l=l; tem.r=r; tem.c=c-1; q.push(tem); }
59     if(valid(l-1,r,c)&&cnt[l-1][r][c]==0){cnt[l-1][r][c]=cnt[l][r][c]+1;tem.l=l-1; tem.r=r; tem.c=c; q.push(tem); }
60     if(valid(l+1,r,c)&&cnt[l+1][r][c]==0){cnt[l+1][r][c]=cnt[l][r][c]+1;tem.l=l+1; tem.r=r; tem.c=c; q.push(tem); }
61
62   }
63 }

田兵 2010-05-28 21:50 发表评论

AOJ 1005 Hero In Maze BFS

田兵 — Thu, 20 May 2010 13:58:00 GMT

Hero In Maze

Time Limit:JAVA/Others2000/1000MS Memory Limit:JAVA/Others131072/65536KB
Total Submit:240 Accepted:51

Description

500年前，Jesse是我国最卓越的剑客。他英俊潇洒，而且机智过人^_^。

突然有一天，Jesse心爱的公主被魔王困在了一个巨大的迷宫中。Jesse听说这个消息已经是两天以后了，他知道公主在迷宫中还能坚持T天，他急忙赶到迷宫，开始到处寻找公主的下落。
时间一点一点的过去，Jesse还是无法找到公主。最后当他找到公主的时候，美丽的公主已经死了。从此Jesse郁郁寡欢，茶饭不思，一年后追随公主而去了。T_T
500年后的今天，Jesse托梦给你，希望你帮他判断一下当年他是否有机会在给定的时间内找到公主。

他会为你提供迷宫的地图以及所剩的时间T。请你判断他是否能救出心爱的公主。

Input

题目包括多组测试数据。
每组测试数据以三个整数N,M,T(00)开头，分别代表迷宫的长和高，以及公主能坚持的天数。
紧接着有M行，N列字符，由"."，"*"，"P"，"S"组成。其中
"." 代表能够行走的空地。
"*" 代表墙壁，Jesse不能从此通过。
"P" 是公主所在的位置。
"S" 是Jesse的起始位置。
每个时间段里Jesse只能选择“上、下、左、右”任意一方向走一步。
输入以0 0 0结束。

Output

如果能在规定时间内救出公主输出“YES”，否则输出“NO”。

Sample Input

4 4 10
....
....
....
S**P
0 0 0

Sample Output

YES

写的第一个BFS，激动！！
代码如下，高手飘过，你们根本不需要看，太初级了。
这个代码主要两个地方花了很多时间：
1，队列本应从队头取元素的，我从尾部取了，后来用queue的front和push可以很方便的实现。
2.，是没有考虑公主被包围的情况，即公主周围全是‘*’，那么王子就没办法达到，这样dist[x2][y2]（x2，y2是公主的位置）一直是0,肯定小于t；

1#include<iostream>
2#include<queue>
3using namespace std;
4char a[105][105];
5bool f[105][105];
6int dist[105][105];
7struct point
8{ int x,y; };
9
10bool valid(int x,int y)
11{ return !f[x][y]&&a[x][y]!='*'&&a[x][y]; }
12
13void bfs(int i,int j)
14{
15     dist[i][j]=0; f[i][j]=1;
16     struct point tem;
17     tem.x=i; tem.y=j;
18     queue<struct point>q;
19     q.push(tem);
20      while(q.size())
21      {
22         tem=q.front();q.pop();
23         int x=tem.x,y=tem.y;
24         if(valid(x-1,y)){f[x-1][y]=1;  dist[x-1][y]=dist[x][y]+1;tem.x=x-1; tem.y=y; q.push(tem);}
25         if(valid(x,y-1)){f[x][y-1]=1;  dist[x][y-1]=dist[x][y]+1;tem.x=x; tem.y=y-1; q.push(tem);}
26         if(valid(x+1,y)){f[x+1][y]=1;  dist[x+1][y]=dist[x][y]+1;tem.x=x+1; tem.y=y; q.push(tem);}
27         if(valid(x,y+1)){f[x][y+1]=1;  dist[x][y+1]=dist[x][y]+1;tem.x=x; tem.y=y+1; q.push(tem);}
28      }
29
30}
31
32int main()
33{
34    int n,m,t,i,j,u;
35    int x,y,x2,y2;
36    while(cin>>m>>n>>t,n||m||t)
37    {
38      memset(a,0,sizeof a);
39      memset(f,0,sizeof f);
40      memset(dist,0,sizeof dist);
41      x=y=x2=y2=1;
42      for(i=1; i<=n; i++)
43      for(j=1; j<=m;j++)
44       {
45                cin>>a[i][j];
46                if(a[i][j]=='S'){x=i; y=j;}
47                else if(a[i][j]=='P'){x2=i; y2=j; }
48       }
49
50       bfs(x,y);
51
52      if(x==x2&&y==y2)cout<<"YES"<<endl;
53      else if(dist[x2][y2]==0)cout<<"NO"<<endl;
54      else if(dist[x2][y2]<=t)cout<<"YES"<<endl;
55      else cout<<"NO"<<endl;
56    }
57
58   return 0;
59}

田兵 2010-05-20 21:58 发表评论

UVa 673 Parentheses Balance

田兵 — Tue, 11 May 2010 02:52:00 GMT

673

Parentheses Balance

Accepted

C++

0.192

简单的括号匹配：
wa了几次

代码：

田兵 2010-05-11 10:52 发表评论

UVa 424 Integer Inquiry 大数加法

田兵 — Mon, 10 May 2010 13:37:00 GMT

这个破题因为数组的边界问题花了我很长时间，也怪自己没有投入里面去

大数加法：

大数加法

田兵 2010-05-10 21:37 发表评论

401 Palindromes

田兵 — Sun, 09 May 2010 14:41:00 GMT

401

Palindromes

Accepted

效率还不错哦
1#include
2#include
3using namespace std;
4
5bool pali(string str)
6{
7     string s="";
8     for(int i=str.size()-1; i>=0; i--)
9       s+=str[i];
10     return str==s;
11}
12
13bool morr(string str)
14{
15     int i;
16     string s="";
17     for( i=str.size()-1; i>=0; i--)
18       s+=str[i];
19     for(i=0;i20      switch(s[i])
21      {
22        case 'A':break;
23        case 'H':break;
24        case 'I':break;
25        case 'M':break;
26        case 'O':break;
27        case 'T':break;
28        case 'U':break;
29        case 'V':break;
30        case 'W':break;
31        case 'X':break;
32        case 'Y':break;
33        case '1':break;
34        case '8':break;
35        case 'E': s[i]='3';break;
36        case 'S':s[i]='2';break;
37        case 'J':s[i]='L';break;
38        case 'L':s[i]='J';break;
39        case 'Z':s[i]='5';break;
40        case '2':s[i]='S';break;
41        case '3':s[i]='E'; break;
42        case '5':s[i]='Z';break;
43        default: return false; break;
44      }
45      return s==str;
46}
47int main()
48{
49    string str;
50    bool p,m;
51    while(cin>>str)
52    {
53             p=pali(str);
54             m=morr(str);
55             cout<56             if(p&&m)cout<<" -- is a mirrored palindrome." <57             else if(p&&!m)cout<<" -- is a regular palindrome." <58             else if(!p&&m)cout<<" -- is a mirrored string." <59             else cout<<" -- is not a palindrome." <60             cout<61    }
62
63return 0;
64}
65

田兵 2010-05-09 22:41 发表评论

用C++中的vector实现的栈

田兵 — Sun, 28 Mar 2010 11:03:00 GMT

没事的时候随便写的，

模拟一下栈，

练习用C++写程序

1#include<iostream>
2#include<vector>
3using namespace std;
4  class Stack
5 {
6 public:
7    inline bool empty();
8  bool full();
9  bool push( int elem);
10  int pop();
11  void getmem();
12  int size(){return _stack.size();}
13 private:
14  vector<int> _stack;
15 };
16  inline bool Stack::empty()
17 {
18          return _stack.empty();
19 }
20
21 inline bool Stack::full()
22 {
23             return _stack.size()==_stack.max_size();
24 }
25 bool Stack:: push(int elem)
26 {
27  if(full())
28   return false;
29  _stack.push_back(elem);
30  return true;
31 }
32
33    int Stack:: pop( )
34 {
35  if(empty())
36   return false;
37  int elem=_stack.back();
38  _stack.pop_back();
39  return elem;
40 }
41   void Stack::getmem()
42   {
43    if(empty())
44     return ;
45    cout<<_stack[0];
46    for(int ix=1;ix!=_stack.size();++ix)
47     cout<<' '<<_stack[ix];
48    cout<49   }
50int main()
51{
52  Stack s;
53  cout<<s.size()<54  for(int i=0,j=1;i<1000;)
55  {
56   s.push(i+j);
57   int k=i;
58   i=j;
59   j=k+i;
60  }
61  cout<<s.size()<62  s.getmem();
63  s.pop();
64  s.pop();
65  s.getmem();
66
67 return 0;
68}

田兵 2010-03-28 19:03 发表评论

C++博客-Programming Every Day-随笔分类-算法笔记

poj 1611 The Suspects

poj 2524 Ubiquitous Religions 【并查集】

poj 3273 Monthly Expense 【二分】

Anagrams by Stack 【集训比赛用题】

滑雪 寄存器数据转换（POJ上的位操作）

USACO chapter 3 section 2 Sweet Butter

POJ 2709 Painter 贪心

背包问题【转】

快速排序

PKU 2251 用DFS TLE了 BFS AC了

AOJ 1005 Hero In Maze BFS

UVa 673 Parentheses Balance

UVa 424 Integer Inquiry 大数加法

401 Palindromes

用C++中的vector实现的栈

没事的时候随便写的，

模拟一下栈，

练习用C++写程序

滑雪寄存器数据转换（POJ上的位操作）