1. 换硬币的题

小明有价值2^k的硬币各2枚，也就是1,1,2,2,4,4,8,8,16,16.....
求给定金额，小明能够支付的方式。
比如，金额为5,输出为[4,1],[2,2,1]

本想使用动态规划，可是，怎么能保证，之前使用了的金额不会在后续中超过次数？？
所以暂时使用了回溯法。
思路：

1. 去重和出点
   将临时数组排序，然后如果最终结果容器中存在这个解，那么不保存，否则保存
2. 遍历和备忘

（没考虑输入的大小，都是用的int）

#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

void coin(vector<vector<int>> &result, vector<int> &temp, vector<int> &memo, int max, int remain)
{
    if (remain == 0)
    {
        vector<int> willPush(temp);
        sort(willPush.begin(), willPush.end());
        if (find(result.begin(), result.end(), willPush) == result.end())
        {
            result.push_back(vector<int>(willPush));
        }
        return;
    }

    if (remain < 0)
    {
        return;
    }

    while ((1 << max) < remain)
    {
        max++;
    }

    while ((1 << max) > remain)
    {
        max--;
    }
    cout << "max: " << max << endl;
    while (memo.size() < max + 1)
    {
        memo.push_back(0);
    }

    for (int start = max; start >= 0; start--)
    {
        if (memo[start] > 1)
        {
            continue;
        }

        memo[start]++;
        temp.push_back((1 << start));

        coin(result, temp, memo, max, remain - (1 << start));
        memo[start]--;
        temp.pop_back();
    }
}

void coinPacking(int n)
{
    //需要判断一下n,k
    vector<vector<int>> result;
    vector<int> temp;
    vector<int> memo(0);
    coin(result, temp, memo, 0, n);
    for (int i = 0; i < result.size(); i++)
    {
        cout << "\n[";
        for (int j = 0; j < result[i].size(); j++)
        {
            cout << result[i][j];
            if ((j + 1) < result[i].size())
            {
                cout << ",";
            }
        }
        cout << "]\n";
    }
}

int main()
{
    int remain;
    cin >> remain;
    coinPacking(remain);
}

这种方法，如果输入是100就需要等一会了。
所以肯定不符合要求。

如果使用动态规划，应该是这样的：

1. memo
   memo应该是一个vector(vector<vector<int>>) memo。memo[i]中保存这金额为i时，所有可能的取值，取值保存k
   比如,memo[5]应该为{{2,0},{1,1,0}}。
   在构建memo的时候同样使用排序，去重。

也是可以的哈。
核心代码可能是这个样子的。
在使用之前的备忘时候，需要先判断该条备忘是否满足不超过2的要求。
还差一些，慢慢改。

void coin2(vector<vector<int>> result,vector<int> temp,
  vector<vector<vector<int>>> memo,long long remain,int old)
{
    if(remain == 0)
    {
        vector<int> pushed(temp);
        sort(pushed.begin(),pushed.end());
        if(find(memo[old].begin(),memo[old].end(),pushed) == memo[old].end())
        {
            memo[old].push_back(pushed);
        }
    }
    return;
    

    for(long long i = 1;i<=remain;i++)
    {
        for(int j = 0 ;j < memo[i].size();i++)
        {
            for(int k = 0;k<memo[i][j].size();i++)
            {
                temp[memo[i][j][k]]++;
                if(temp[memo[i][j][k]] == 2)
                {
                    break;
                }
            }
            coin2(result,temp,memo,remain - (1<<i),old);
            
        }
    }
}