TSP问题（旅行商问题）是指旅行家要旅行n个城市，要求各个城市经历且仅经历一次然后回到出发城市，并要求所走的路程最短。

      假设现在有四个城市，0,1,2,3，他们之间的代价如图一，可以存成二维表的形式

                      图一                                                                                               

        现在要从城市0出发，最后又回到0，期间1，2，3都必须并且只能经过一次，使代价最小。

2.动态规划可行性

        设s, s1, s2, …, sp, s是从s出发的一条路径长度最短的简单回路，假设从s到下一个城市s1已经求出，则问题转化为求从s1到s的最短路径，显然s1, s2, …, sp, s一定构成一条从s1到s的最短路径，所以TSP问题是构成最优子结构性质的，用动态规划来求解也是合理的。

3.推导动态规划方程

        假设从顶点s出发，令d(i, V’)表示从顶点i出发经过V’(是一个点的集合)中各个顶点一次且仅一次，最后回到出发点s的最短路径长度。

        推导：(分情况来讨论)

        ①当V’为空集，那么d(i, V’)，表示从i不经过任何点就回到s了，如上图的 城市3->城市0(0为起点城市)。此时d(i, V’)=Cis(就是 城市i 到 城市s 的距离)、

        ②如果V’不为空，那么就是对子问题的最优求解。你必须在V’这个城市集合中，尝试每一个，并求出最优解。

           d(i, V’)=min{Cik +  d(k, V’-{k})}

           注：Cik表示你选择的城市和城市i的距离，d(k, V’-{k})是一个子问题。

        综上所述，TSP问题的动态规划方程就出来了：

4.实例分析

     现在对问题定义中的例子来说明TSP的求解过程。(假设出发城市是 0城市)

    ①我们要求的最终结果是d(0,{1,2,3}),它表示，从城市0开始，经过{1,2,3}之中的城市并且只有一次，求出最短路径.

    ②d(0,{1,2,3})是不能一下子求出来的，那么他的值是怎么得出的呢？看上图的第二层，第二层表明了d(0,{1,2,3})所需依赖的值。那么得出：

       d(0,{1,2,3})=min  {

                                    C01+d(1,{2,3})

                                    C02+d{2,{1,3}}

                                    C03+d{3,{1,2}}

                                  }

     ③d(1,{2,3})，d(2,{1,3})，d(3,{1,2})同样也不是一步就能求出来的，它们的解一样需要有依赖，就比如说d(1,{2,3})

       d(1,{2,3})=min{

                              C12+d(2,{3})                             

                              C13+d(3,{2})

                              }

       d(2,{1,3})，d(3,{1,2})同样需要这么求。

    ④按照上面的思路，只有最后一层的，当当V’为空集时，Cis的值才可以求，它的值是直接从

这张表里求得的。

     5.编程思路

        将d(i, V’)转换成二维表，d[i][j]

        在程序中模拟填表的过程，主要要考虑到j这个参数的表示，它要代表一个集合，可以用二维数组来表示。

   6.源代码

注：由于本人水平有限，并且主要在这里是体现思路，所以程序并不是很完善，代码质量也不高，很地方可以写得通用一些，所以这里只是提供一个参考，程序的进一步完善，由读者自由发挥。

#include 
#include

int IsIncluded(int x,int array[3])//x是否包含在数组中 
{ 
    if((array[0] != x) && (array[1] != x) && (array[2] != x)) 
        return 0; 
    return 1; 
} 
int Left(int k,int array[3],int V[8][3])//实现V'-{k} 的下标检索 
{ 
    int i = 0,index = 0,array_0_count = 0,array_1_count = 0,array_2_count = 0,array_3_count = 0; 
    int V_0_count = 0,V_1_count = 0,V_2_count = 0,V_3_count = 0; 
    int temp[3]; 
    for(i = 0; i < 3; i++) 
        temp[i] = array[i]; 
    for(i = 0; i < 3; i++) 
        if(temp[i] == k) 
            temp[i] = 0;  //相当于去掉k这个城市 
    for(i = 0; i < 3; i++) 
    { 
        if(temp[i] == 0) 
            array_0_count++; 
        else if(temp[i] == 1) 
            array_1_count++; 
        else if(temp[i] == 2) 
            array_2_count++; 
        else 
            array_3_count++; 
    } 
    for(index = 0; index < 8; index++) 
    { 
        for(i=0; i < 3; i++) 
        { 
            if(V[index][i] == 0) 
                V_0_count++; 
            else if(V[index][i] == 1) 
                V_1_count++; 
            else if(V[index][i] == 2) 
                V_2_count++; 
            else 
                V_3_count++; 
        } 
        if((array_0_count == V_0_count) && (array_1_count == V_1_count) 
            && (array_2_count == V_2_count) && (array_3_count == V_3_count)) 
            return index; 
        V_0_count = 0; 
        V_1_count = 0; 
        V_2_count = 0; 
        V_3_count = 0; 
    } 
    return 0; 
}

void TSP(int d[4][8],int c[4][4],int V[8][3],int n) 
{ 
    int i = 0,j = 0,k = 0;

    for(i = 1; i < n; i++)//V'为空时，给赋值， 
        d[i][0] = c[i][0];

    for(j = 1; j < 7; j++)//按列遍历不同集合，{1},{2},{3},{1,2},{1,3}..... 
    { 
        for(i = 1; i < n; i++)//遍历城市1，2，3 
        { 
            if( !IsIncluded(i,V[j]) )//i必须不在集合中，否则就属于经过两次，不符合题意 
            { 
                for(k = 0; k < 3; k++)//分别试探集合中的每一点，取最小值 
                { 
                    if((V[j][k] != 0) && ((c[i][V[j][k]] + d[V[j][k]][Left(V[j][k],V[j],V)]) < d[i][j])) 
                        d[i][j] = c[i][V[j][k]] + d[V[j][k]][Left(V[j][k],V[j],V)]; 
                } 
            } 
        }//end of     for(i = 1; i < n; i++)//遍历城市1，2，3 
    }//end of for(j = 1; j < ((int)pow(2,n)-1); j++) 
    for(k = 0; k < 3; k++)//分别试探下一步为集合中的任何一点，取最小值 
    { 
        if((V[7][k] != 0) && (c[0][V[7][k]] + d[V[7][k]][Left(V[7][k],V[7],V)]) < d[0][7]) 
            d[0][7] = c[0][V[7][k]] + d[V[7][k]][Left(V[7][k],V[7],V)]; 
    } 
} 
void main() 
{ 
    int V[8][3]= 
    { 
        0,0,0, 
        0,0,1, 
        0,0,2, 
        0,0,3, 
        0,1,2, 
        0,1,3, 
        0,2,3, 
        1,2,3 
    }; 
    int c[4][4]= 
    { 
        0,3,6,7, 
        5,0,2,3, 
        6,4,0,2, 
        3,7,5,0 
    }; 
    int d[4][8]={0},i=0,j=0;

    for(i=0; i<4; i++) 
        for(j=0; j<8; j++) 
            d[i][j]=1000;   //假设1000为无穷大 
    TSP(d,c,V,4); 
    printf("The least road is:%d/n",d[0][7]); 
}

2^nd JOJ Cup Online VContest Problem

We all know that bunny is fond of carrots. One cloudy day, he was told that there would be a violenting flood coming soon to destroy the forests. He was scared and after not thinking too much he told himself that he had to escape. He suddenly recalled that there was a temple on the top of the hill and he might shelter there until the flood's past. But unfortunately there was no food for him on the top of the hill, so he had to take his carrots away along with himself. Then he moved to the foot of the hill and stopped. There was only one way for him to get the top of the hill, that is, a long staircase. Given the number of the steps of the staircase, he asked himself:"how many different ways of strides are there for him to get the top of the hill?". Of course, because of his height, he could only stride a limited range of steps. He was smart so much so that he got the answer quickly. Do you know how he did it?

Input Specification

The input consists of several test cases, each of which occupies a line containing M(1<=M<=40) and N(1<=N<=10), where M indicates the number of the steps of the staircase and N indicates the maximal number of steps the bunny can stride once.

Output Specification

Each test case should correspond to a line in the output. Your program should print an integer which is the answer.

Sample Input

4 2
5 4

Sample Output

5
15


题意是一只兔子要到距离为M（单位为1）的地方，它每步最多走N，问有多少种方法。输入M  N 输出r[m][n];

Input

Input will consist of a series of real numbers no greater than $50.00 each on a separate line. Each amount will be valid, that is will be a multiple of 5c. The file will be terminated by a line containing zero (0.00).

Output

Output will consist of a line for each of the amounts in the input, each line consisting of the amount of money (with two decimal places and right justified in a field of width 5), followed by the number of ways in which that amount may be made up, right justified in a field of width 12.

Sample input

0.20
2.00
0.00

Sample output

0.20           4
2.00         293

典型的动态规划问题：

可以先考虑只有n-1种硬币，V1,V2,V3,---Vn-1.设凑成总值为M的方法数为result[M];

现在又添加一种面值为Vn的硬币。

则咱们需要修改一些值，修改那些大于等于Vn的result[],不妨设M大于vn。

新result[M]=原result[M]+result[M-Vn]+result[M-2*Vn]+----直到M-p*Vn<=0;（1）

实际上如果如(2)那样处理 从大于等于Vn的result[]开始处理的话，从小到大，设Vn=M-p*Vn;

则result[M-p*Vn]第一个最先更新，result[M-p*Vn]+=result[M-p*Vn -Vn]   见(2)
随后更新result[M-(p-1)*vn]，则只需直接加上result[M-p*Vn]的值，无需如（1）式那样  累加。

用程序表达就是

int coin[10]={5,10,20,50,100,200,500,1000,2000,5000};

for(i=1;i<10;i++)

 for(j=coin[i];j<=50000;j+=5)

     result[j]+=result[j-Coin[i]];   (2) //

-------------

还有一个注意点，见牛人博客，http://hi.baidu.com/piaoshi111/blog/item/9a6de84a00a6e5f882025c89.html

就是浮点数的四舍五入，

1.5，浮点数可能表为1.4999999，所以乘以100时转化为整型是149，应当注意。

You want to arrange the window of your flower shop in a most pleasant way. You have F bunches of flowers, each being of a different kind, and at least as many vases ordered in a row. The vases are glued onto the shelf and are numbered consecutively 1 through V, where V is the number of vases, from left to right so that the vase 1 is the leftmost, and the vase V is the rightmost vase. The bunches are moveable and are uniquely identified by integers between 1 and F. These id-numbers have a significance: They determine the required order of appearance of the flower bunches in the row of vases so that the bunch i must be in a vase to the left of the vase containing bunch j whenever i < j. Suppose, for example, you have bunch of azaleas (id-number=1), a bunch of begonias (id-number=2) and a bunch of carnations (id-number=3). Now, all the bunches must be put into the vases keeping their id-numbers in order. The bunch of azaleas must be in a vase to the left of begonias, and the bunch of begonias must be in a vase to the left of carnations. If there are more vases than bunches of flowers then the excess will be left empty. A vase can hold only one bunch of flowers.

Each vase has a distinct characteristic (just like flowers do). Hence, putting a bunch of flowers in a vase results in a certain aesthetic value, expressed by an integer. The aesthetic values are presented in a table as shown below. Leaving a vase empty has an aesthetic value of 0.

According to the table, azaleas, for example, would look great in vase 2, but they would look awful in vase 4.

To achieve the most pleasant effect you have to maximize the sum of aesthetic values for the arrangement while keeping the required ordering of the flowers.

ASSUMPTIONS

1 ≤ F ≤ 100 where F is the number of the bunches of flowers. The bunches are numbered 1 through F. F ≤ V ≤ 100 where V is the number of vases. -50 ≤ Aij ≤ 50 where Aij is the aesthetic value obtained by putting the flower bunch i into the vase j.

Input

The first line contains two numbers: F and V.

The following F lines: Each of these lines contains V integers, so that Aij is given as the j’th number on the (i+1)’st line of the input file.

Notice: The input contains several test cases.

Output

The output line will contain the sum of aesthetic values for your arrangement.

Sample Input

3 5
7 23 -5 -24 16
5 21 -4 10 23
-21 5 -4 -20 20

Sample Output

53

技巧：设置一个数组a[i]

存放所有长度为i的上升子序列中最小的末元素值，比如说只有两个长度为3的上升子序列123和124，那么a[3]中存放的就是3（末元素3<4）

那么当来一个新数data时，如果它的值大于最长长度的末元素的值（即a[ans]），则ans++；且a[ans]=data;

否则，通过二分查找（数组a中的元素为递增），将最接近data且大于data的那个元素更新为data，既最小的大于它的数。
例如1,5,3,4,之后来个2，a[1]=1,a[2]=3,a[3]=4;则更新a[2]=2;
由于二分查找复杂度为log(n)，外围为n,总的复杂度为nlogn

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;
}

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;
}

Input

Output

Sample Input

3
1 2 9

Sample Output

15

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