搜索：主要是DFS和BFS，特别一点是注意剪枝。
　　　1010 Tempter of the Bone  DFS+奇偶剪枝。
             1016   Prime Ring Problem  简单的DFS，第一次没看清题目，没注意尾部和首部相加也要是素数。可以先用一个数组把素数先标记好，那DFS就很简单了。
              1181   变形课 简单的DFS。用邻接矩阵将首尾字母保存，从字母‘b’开始DFS搜索。注意跳过已经搜过的字母。
              1195   Open the Lock   2717 Catch That Cow  简单BFS。注意跳过已经搜索过的。
              1240   Aseroids！  简单的BFS。错了几次是因为没把数据用多维数组保存好。
              1241    Oil Deposits   DFS和BFS都可以。斜线方向也是可以的。
              1242   Rescue    BFS。但是注意可能由多个Freind，所以从Angle开始搜。
              1312   Red and Black  简单DFS。
              1198    Farm Irrigation 可以用BFS，但我是用“并查集”做的。

DP：这个是弱点，所以没做多少，只做一些简单的。
              1003  MaxSum 最长连续子序列，经典DP，基本DP。
              1024  MaxSum Plus Plus 关键是如何降维，将O^3最后变成O^2的，否则会超时。
              1114   Piggy-Bank 完全背包问题。
              1159   Common Subsequence  最长公共字串，经典DP问题。
              1203   I NEED A OFFER！0-1背包问题。
              1257   最少拦截系统  一个简单方法，利用vector 开一个动态数组，每次读一个数据，从前扫描过来，遇到比所读数据大的，就更新那个数据为所读数据，最后，该数组长度就是导弹系统个数。
              1559   最大子矩阵   对数组中的数据做下修改，对于a[i][j] 重新更新为 a[1][1]—a[i][j] 子矩阵的和，然后就可以搜一下整个数组就能得到最大子矩阵了。
              1428  漫步校园 先是从终点BFS到起点，把耗费保存在一个表中，然后再从起点DFS终点求的所有路线，但注意要记录已经遍历过的点，下次遍历就直接加上上次遍历所得的路线数目，否则会超时。

图论：主要做了 单源最短路径--Dijkstra算法，所有点的-Floyd算法；最小生成树--Prim算法，另外那个还没写过( = =! )； 最大子团--回溯法
              1217   Arbitrage  建立一个有向图，利用Floyd算法，问题也就是求通过其他点到自己有没有增加。
              1596  find the safest road 所有点最短路径--Floyd可以解决。
              1530  Maxumum Clique 最大子团  回溯法，就是耗时比较多。
              1162  Eddy’s picture  最小生成树--Prim算法
              1232 畅通工程 赤裸裸的并查集。
              1301 Jungle Roads 还是最小生成树

题目原文：http://acm.hdu.edu.cn/showproblem.php?pid=1789

题目大意：要在指定的日期内完成作业，并且每个作业只需要1天的时间并且每天只能做一个作业，没完成的就会扣相应的学分，要求被扣最少的学分。

题目分析：
              起初我是这样想得：
                    1。如果在指定的日期内完成则不会扣分，且每个作业只需要一天完成，那么肯定会想到先把学分多的先做，是不是这样就能行呢,先看一组例子吧：

               1 4 6 4 2 4 3
               3 2 1 7 6 5 4
如果只考虑学分多的先做那么排列就会是：7654321 ，但这并不是最优的安排。

                     2。换个角度想了想，要使扣分少，我应该尽量使扣分少的过期在做，最好要让学分多的在它指定的那天完成，这样就会使得这天被扣分数尽量少。
结果思路就出来了： 1。先处理分数多的作业，把分数多的安排在它最后期限那一天。
                              2。如果那天被占用了，就往前一天安排。
                              3。如果前面没有日期了，就安排最后那天处理这个作业。此时就要扣掉对应的学分。

算法设计：1。利用STL中的sort()进行排序，但是因为定义了一个数据结构，需要重新写个判断函数。
                2。定义一个vist[]数组来标记该天是否被安排

代码设计如下：

#include "iostream"
#include <algorithm> //need sort()
using namespace std;
struct Homwo //作页日期和分数的结构
{
int date;
int score;
}p[10002];
//以分数排名
bool cmp(const Homwo m,const Homwo n)
{
     return m.score>n.score?1:0;
}
int main()
{
    int t;
    cin>>t;
    while (t—)
{
int n;
int vist[10002]={0};
int flag,k=0;
cin>>n;
for (int i=1;i<=n;i++)
{
cin>>p[i].date;
}
for (i=1;i<=n;i++)
{
cin>>p[i].score;
}
sort(p+1,p+n+1,cmp);//注意数组时从1开始的！按学分排列
for (i=1;i<=n;i++)
{
if(vist[p[i].date]==0)  vist[p[i].date]=1;
else
{
for (int j=p[i].date-1,flag=0;j>0;j--)
{
if(vist[j]==0) 
                     {    vist[j]=1;
                          flag=1; 
                          break;
                      }
}
if (flag==0)
{
for (j=n;j>p[i].date;j--)
{
if(vist[j]==0)
{
vist[j]=1;
k=k+p[i].score;
break;
}
}
}
             }
          } 
          cout<<k<<endl;
}
return 0;
}

      题目大意：给出起始位置和终点位置，要求在指定的时间刚好到达终点时间，每移动一步一秒，并且不能返回。   

      题目分析：

                  1。起初以为能用BFS做，后来发现，必须在指定的时间内抵达终点才行，BFS无法达到要求。

                  2。要求在指定时间内到达，唯一想法就是能不能枚举出所有抵达方案，再在通过检查时间时间是否吻合，得到结果，这就自然想到了用DFS进行搜索。

                  3。DFS搜索完成后，提交发现超时，看样子还得剪枝才行，无奈啊，百度一下。

                  4。剪枝方法：奇偶剪枝

                             把map看作

                             0 1 0 1 0 1
                             1 0 1 0 1 0
                             0 1 0 1 0 1
                             1 0 1 0 1 0
                             0 1 0 1 0 1

                       从 0->1 需要奇数步

                       从 0->0 需要偶数步
                       那么设所在位置 (x,y) 与 目标位置 (dx,dy)

                       如果abs(x-y)+abs(dx-dy)为偶数，则说明 abs(x-y) 和 abs(dx-dy)的奇偶性相同，需要走偶数步

                       如果abs(x-y)+abs(dx-dy)为奇数，那么说明 abs(x-y) 和 abs(dx-dy)的奇偶性不同，需要走奇数步

                       理解为 abs(si-sj)+abs(di-dj) 的奇偶性就确定了所需要的步数的奇偶性！！

                       而 (ti-setp)表示剩下还需要走的步数，由于题目要求要在 ti时 恰好到达，那么  (ti-step) 与 abs(x-y)+abs(dx-dy) 的奇偶性必须相同

                       因此 temp=ti-step-abs(dx-x)-abs(dy-y) 必然为偶数！

                5。最后一点：整个图的可以移动步数应该大于指定的时间

#include "iostream"
#include <math.h>
using namespace std;
int dir[4][2]={{-1,0},{0,1},{1,0},{0,-1}};
int n,m;
char a[7][7];
int sx,sy,dx,dy;
int ti,flag;
void DfsSerch(int x,int y,int step)
{
/////////////////////////////////////
int temp;
temp=ti-step-abs(dx-x)-abs(dy-y);
if (temp<0||temp%2==1) return;
////////////////////////////////////
int tx,ty;
for(int i=0;i<4;i++)  //方向探索
{
tx=x+dir[i][0];
ty=y+dir[i][1];
if (a[tx][ty]=='D'&&step==ti-1)
{
flag=1;
return ;
}
if(a[tx][ty]=='.'&&(tx>=0&&tx<n)
&&(ty>=0&&ty<m))
{
a[tx][ty]='X';  //标记访问 
DfsSerch(tx,ty,step+1);
a[tx][ty]='.';  //回溯取消标记
if(flag==1) return;//找到直接返回
}
}
}
int main()
{
while (cin>>n>>m>>ti&&n!=0||m!=0||ti!=0)
{
///////////////////////////////////////
//输入数据
int wall=0;
for (int i=0;i<n;i++)
for(int j=0;j<m;j++)
{
cin>>a[i][j];
if(a[i][j]=='S')
{
sx=i;
sy=j;
}
if (a[i][j]=='D')
{
dx=i;
dy=j;
}
if (a[i][j]=='X')
{
wall++;
}
}//for-for
/////////////////////////////////////
flag=0;
if (n*m-wall<=ti)
{
cout<<"NO"<<endl;
continue;
}
DfsSerch(sx,sy,0);
if(flag==1)
cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
return 0;
}