Given a specified total t and a list of n integers, find all distinct sums using numbers from the list that add up to t. For example, if t = 4, n = 6, and the list is [4, 3, 2, 2, 1, 1], then there are four different sums that equal 4: 4, 3+1, 2+2, and 2+1+1. (A number can be used within a sum as many times as it appears in the list, and a single number counts as a sum.) Your job is to solve this problem in general.

Input

Output

Sample Input

4 6 4 3 2 2 1 1
5 3 2 1 1
400 12 50 50 50 50 50 50 25 25 25 25 25 25
0 0

Sample Output

Sums of 4:
4
3+1
2+2
2+1+1
Sums of 5:
NONE
Sums of 400:
50+50+50+50+50+50+25+25+25+25
50+50+50+50+50+25+25+25+25+25+25

想法 ： 这个题目以前出现在08年一个热身赛上，当时就没有过，然后一直放到现在，才过了的。还是想了好长时间的。

由于这个题目不能有重复的结果，所以我们把输入的数字分类，也就是说，有几个几。这样，我们再按照种类进行dfs 的时候，就不会出现重复的了，因为每个种类

每次dfs 从当前的index 走到下面，不会出现重复的情况。 

再需要解决的就是求和的为题，求和很简单了，我们记录每种数有几个，从大到小，进行枚举，它的和就可以了。

再需要解决路径，就是做点改变，用一个二维的数组，记录有几个几，第一维记录几个数字，第二维记录这个数字是什么。

附代码 ：

#include <stdio.h>
#include <string.h>

int many[101], in[13], sum, n, kind[13], dif;
int path[50][2];
bool judge[100], ok;
void dfs(int index, int s, int pl){
    int i, j;
    if(s == sum){
        ok = true;
        bool f = false;
        for(i = 0; i < pl; i++){
            for(j = 0; j < path[i][0]; j++){
                if(!f)f = true;
                else putchar('+');
                printf("%d", path[i][1]);
            }
        }
        puts("");
    }
    else{
        for(i = index; i < dif; i++){ // 对于种类，dfs
            if(!judge[i]){
                for(j = many[kind[i]]; j >= 1; j--){ // 每种由大到小，枚举所有的可能性
                    if(s + j * kind[i] <= sum){
                        judge[i] = 1;  //标记走过
                        path[pl][0] = j;  //记录有多少个这个数
                        path[pl][1] = kind[i];  //记录某个数字
                    //    printf("dfs %d ge %d  sum = %d\n", j, kind[i], s + kind[i]);
                        dfs(i, s + j * kind[i], pl + 1);
                        judge[i] = 0; // 回溯
                    }
                }
            }
            
        }
    }
}
int main(){
    freopen("1197.in", "r", stdin);
    freopen("1197.out", "w", stdout);
    int i, j;
    while(scanf("%d%d", &sum, &n), sum || n){
        dif = 0;ok = false;
        memset(many, 0, sizeof(many));
        memset(in, -1, sizeof(in));
        memset(kind, 0, sizeof(kind));
        for(i = 1; i <= n; i++)
            scanf("%d", &in[i]);
        for(i = 0, j = 1; j < n; j++, i++){
            if(in[i] != in[j]){
                kind[dif++] = in[j]; // 提取种类
                many[in[j]] = 1; //每种多少个。
            }
            else many[in[j]]++;
        }
        if(in[n] != in[n - 1]){
            kind[dif++] = in[n];  //。。。最有也有一个。
            many[in[n]] = 1;
        }
        else many[in[n]]++;
        printf("Sums of %d:\n", sum);
        dfs(0, 0, 0);
        if(!ok)puts("NONE");
    }
    return 0;
}

对于dfs 的理解还是不好的。非常不好，这个题目还是想了很长时间，想象不出来进入dfs后的情况。

4           //矩阵范围
2331        //矩阵
1213
1231
3110






想法 ：开始想到bfs，交过，tle，但是后来想感觉即使不超时也不对，因为一个点有可能走过多次。是我自己的想法。后来越看越像dp了，最后
的目标点，到他的路径，是它左边的能走到它的点，和右边能走到它的点的路径的和，那么，这样推上去，就可以划分出它的子问题。(汗，这样写
大家不要笑话，因为我没有看过算法导论上的dp)，因该是属于递推吧。再从上往下，一直推到目标点。就可以了。

只能向右 ：横坐标单调递增

只能向下 ：纵坐标单调递增

因为起点的能第一次达到的点的路径个数一定是1，所以最后存储结果的res[0][0] = 1;


核心代码 ：

1. 因为横纵都是单调递增的，所以横向检测图中从点(small, column)到点(big, column)有没有0值的点，直接枚举每个位置，且不包含
两个端点


1 bool rok(int s, int b, int c){
2     int i;
3     for(i = s + 1; i < b; i++)
4         if(!map[i][c])return false;
5     return true;
6 }




2.因为横纵都是单调递增的，所以横向检测图中从点(row, small)到点(row, big)有没有0值的点，直接枚举每个位置，且不包含
两个端点



1 bool cok(int s, int b, int r){
2     int i, j;
3     for(i = s + 1; i < b; i++)
4         if(!map[r][i])return false;
5     return true;
6 }




3.递推的过程，从前往后，进行递推，如果不是只能向右或者向下，是不满足递推的条件的，不是单调的(不知道这里理解的对不对)



 1         res[0][0] = 1; //起始点的第一个到达的点的路径个数一定是1。
 2         for(i = 0; i < n; i++){
 3             for(j = 0; j < n; j++){
 4                 if(res[i][j] && i != n - 1 || j != n - 1){ //可达，而且不是右下角的点
 5                     //向右                
 6                     if(i + map[i][j] < n && rok(i, i + map[i][j], j)) //若在图内，且从起点到滚动停止点，图中没有0值点
 7                         res[i + map[i][j]][j] += res[i][j]; //滚动停止点的路径条数 = 起始点的路径条数 + 停止点的路径条数
 8                     //向下
 9                     if(j + map[i][j] < n && cok(j, j + map[i][j], i))
10                         res[i][j + map[i][j]] += res[i][j];
11                 }
12             }
13         }



ps : 题目提示c或者c++要用long long存储结果，可是"%ld"输出wa了n次，后来看了discuss后改的"%I64d"输出后ac

     
1 printf("%I64d\n", res[n - 1][n - 1]);

4 1 // 4个点 1个已经连完的边
1 1  //点坐标
3 1
2 3
4 3
1 4  //连接完毕的点地编号


想法 ：将连接完毕的点地权值更改为0，克鲁斯 + 并查  或者  将已经连接的点先并入一个集合

核心代码如下 ：

1. 将已经连接的点先并入一个集合


1 for(i = 0; i < m; i++){
2             scanf("%d%d", &u, &v);
3             if((u = find(u)) != (v = find(v))){
4                 f[u] = v;
5                 n--;
6             }
7         }



2. 并查集合


int find(int x){
    if(x != f[x])return f[x] = find(f[x]);
    return f[x];
}


3. 克鲁斯卡尔 + 并查


 1 tel = el;
 2         make_heap(e, e + el, cmp);
 3         for(i = 0; i < n - 1; tel--){
 4             if((u = find(e[0].u)) != (v = find(e[0].v))){
 5                 f[u] = v;
 6                 sum += e[0].w;
 7                 i++;
 8             }
 9             pop_heap(e, e + tel, cmp);
10         }

2 1 1 2 (0,1)20 (1,0)10 (0)15 (1)20   


 //总共两个点  一个发电厂，一个用户，2条边，(0, 1)点容量为20，(1， 0)点容量为10，编号为0的点是发电厂，即源，编号为1的点是用户，即汇



7 2 3 13 (0,0)1 (0,1)2 (0,2)5 (1,0)1 (1,2)8 (2,3)1 (2,4)7  
         (3,5)2 (3,6)5 (4,2)7 (4,3)5 (4,5)1 (6,0)5
         (0)5 (1)2 (3)2 (4)1 (5)4

//意思同上