贪心策略1

贪心策略，每次找局部最优解

堆和排序是最常用的技巧

哈夫曼编码

#include <iostream>

#include<queue>

using namespace std;
const int N = 1000000;



int haf(priority_queue<int,vector<int>,greater<int>> &heap){
    int sum=0;

    int num1,num2,num;
    while(heap.size()>1){
    num1=heap.top();
    heap.pop();
    num2=heap.top();
    heap.pop();

    num=num1+num2;
    sum+=num;

     heap.push(num);
    }
    return sum;
}


int main()
{
    priority_queue<int,vector<int>,greater<int>> heap;
    int n;
    cin>>n;
    int cur;
    for(int i=0;i<n;i++){
        cin>>cur;
        heap.push(cur);
    }

   cout<<haf(heap);
    return 0;
}

题目2： 

#include <iostream>
#include <queue>
using namespace std;
typedef pair<int, int> P;

// 自定义数据类型，需要重写operator方法，给花费用，小根堆
struct smallStack
{
    bool operator()(P a, P b)
    {
        return a.first > b.first;
    }
};
// 自定义数据类型，需要重写operator方法，给利润用，用大根堆
struct bigStack
{
    bool operator()(P a, P b)
    {
        return a.second < b.second;
    }
};
priority_queue<P, vector<P>, smallStack> cost;//花费小根堆，按花费排序
priority_queue<P, vector<P>, bigStack> profit;//利润大根堆，按利润排序

int getSum(int k,int m){

    while (k)
    {
        P temp;
        while (m >= cost.top().first)//将满足条件(资金＞花费的项目)从花费小根堆放到利润大根堆里
        {
            temp = cost.top();
            cost.pop();
            profit.push(temp);
        }
        if (!profit.empty())//利润堆非空，从堆顶(也就是利润最大)取出一个项目
        {
            temp = profit.top();
            profit.pop();
            m += temp.second;
        }
        else
            {break;}//利润堆为空，说明没有项目满足，退出循环
        k--;
    }
    return  m;
}

int main()
{
    int n, k, m;
    cin >> n >> k >> m;
    int num1, num2;
    int arr[n][2];

    //初始化数据
    for (int i = 0; i < n; i++)
    {
        cin >> arr[i][0] >> arr[i][1];
    }
    //建堆
    for (int i = 0; i < n; i++)
    {
        cost.push({arr[i][0], arr[i][1]});
    }

    cout<<getSum(k,m);
    return 0;
}

回溯法，主要就是暴力递归

再递归的下面一行，二叉树其实都有回溯的过程，就看你用不用了

精髓:一层递归就是一层for循环

回溯问题就是要很多很多for循环的，可以用树形结构题先画一画。

1.递归函数参数返回值

2.确定终止条件

3.单层递归逻辑

剪枝还是蛮有意思的

class Solution {
public:

vector<vector<int>> resFin;
vector<int> res;
    void backTracking(int n,int k,int startIndex){
        int len=res.size();
        if(k==len){
            resFin.push_back(res);
            return;
        }
            for(int i=startIndex;i<=(n-(k-len)+1);i++){
                res.push_back(i);
                backTracking(n,k,i+1);
                res.pop_back();
}
        return ;


    }
    vector<vector<int>> combine(int n, int k) {
            backTracking(n,k,1);
            return resFin;
    }
};

这个剪枝方法太妙了！按照卡神的说法，一个是树枝剪枝(通过i+1来跳过)，一个是树层剪枝(通过如果有相同的元素，只使用其中的最左一组，代码通过continue那行实现) 

class Solution {
public:
vector<vector<int>> resFin;
vector<int> res;
//unordered_set<vector<int>> set;
int sum=0;
    void backTracking(vector<int> & candidates,int target,int startIndex){
        int len=candidates.size();
        if(sum==target){
            // set.insert(res);
           resFin.push_back(res);
            return;
        }

    if(sum>target)return;

        for(int i=startIndex;i<len;i++){
            if((i>startIndex)&&(candidates[i]==candidates[i-1]))continue;//这行是核心中的核心！！树层剪枝
            int cur=candidates[i];
            res.push_back(cur);
            sum+=cur;
            backTracking(candidates,target,i+1);//好几次这里出错了！！！！！
            sum-=cur;
            res.pop_back();
        }


    }


    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());

        backTracking(candidates,target,0);

        // for(auto v:set){
        //     resFin.push_back(v);
        // }
        return resFin;

    }
};

 虽然这题时间复杂度较高，但是也是自己写的，满意了

class Solution {
public:
    vector<vector<string>> resFin;
    vector<string> path;
    bool flag=false;
    bool judge(string cur){
        int end=cur.size()-1;
        int start=0;
        while(start<end){
            if(cur[start]!=cur[end])return false;
        start++;
        end--;
        }
        return true;

    }
    void huiwen(string s,int startIndex,string cur){
        int len=s.size();

        if(startIndex==len&&flag==true)
        {
            if(flag){resFin.push_back(path);
            flag=false;}

        return;}

         
        for(int i=startIndex;i<len;i++){
           cur=cur+s[i];
           if(!judge(cur)){
            flag=false;
            huiwen(cur,i+1,cur);
            }else{
                flag=true;
                path.push_back(cur);
                huiwen(s,i+1,"");
                 path.pop_back();
            }

           
        }
    }
    vector<vector<string>> partition(string s) {
            huiwen(s,0,"");

            return resFin; 
    }
};

全排列！！感觉已经有点懂回溯了！！，都是自个儿写的代码 

//22:09
class Solution {
public:
    vector<vector<int>> resFin;
    vector<int> path;

    void backTracking(vector<int>&nums,vector<int> &visit,int startIndex){
        int len=nums.size();
        if(path.size()==len){
            resFin.push_back(path);

            return;
        }

        for(int i=0;i<len;i++){

            if(visit[i]==0){
                
            path.push_back(nums[i]);
            visit[i]=1;
             backTracking(nums,visit,(i+1)%len);
             visit[i]=0;
             path.pop_back();
            }
            
           
        
        }

    }

    vector<vector<int>> permute(vector<int>& nums) {
        int len=nums.size();
            vector<int> visit(len);
            visit={0};

            backTracking(nums,visit,0);

            return resFin;
    }
};