算法基础模板题1-10

2. 01背包问题

• 背包问题 DP

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。

第 i 件物品的体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。

接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。

输出格式
输出一个整数，表示最大价值。

数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例：
8

#include <iostream>

using namespace std;

const int N = 1010;
int w[N];
int v[N];
int f[N][N];

int main() {
    int n, m;
    cin >> n >> m;
    for(int i = 1; i <= n; i ++) {
        cin >> v[i] >> w[i];
    }
    
    for(int i = 1; i <= n; i ++) {
        for(int j = 1; j <= m; j ++) {
            if(j < v[i]) {
                f[i][j] = f[i - 1][j];
            } else {
                f[i][j] = max(f[i - 1][j], f[i - 1][j - v[i]] + w[i]);
            }
        }
    }
    
    cout << f[n][m] << endl;
    return 0;
}

#include <iostream>

using namespace std;

const int N = 1010;
int v[N];
int w[N];
int f[N];

int main() {
    int n, m;
    cin >> n >> m;
    for(int i = 1; i <= n; i ++) {
        cin >> v[i] >> w[i];
    }
    
    for(int i = 1; i <= n; i ++) {
        for(int j = m; j >= 0; j --) {
            if(j >= v[i]) {
                f[j] = max(f[j], f[j - v[i]] + w[i]);
            }
        }
    }
    
    cout << f[m] << endl;
    
    return 0;
}

#include <iostream>

using namespace std;

const int N = 1010;
int v[N];
int w[N];
int f[N];

int main() {
    int n, m;
    cin >> n >> m;
    for(int i = 1; i <= n; i ++) {
        cin >> v[i] >> w[i];
    }
    
    for(int i = 1; i <= n; i ++) {
        for(int j = m; j >= v[i]; j --) {
            f[j] = max(f[j], f[j - v[i]] + w[i]);
        }
    }
    
    cout << f[m] << endl;
    
    return 0;
}

#include <iostream>

using namespace std;

const int N = 1010;
int f[N], v[N], w[N];

int main() {
    int n, m;
    cin >> n >> m;
    for(int i = 0; i < n; i ++) {
        cin >> v[i] >> w[i];
        for(int j = m; j >= 0; j --) {
            if(j >= v[i]) {
                f[j] = max(f[j], f[j - v[i]] + w[i]);
            }
        }
    }
    
    cout << f[m] << endl;
    
    return 0;
}

3. 完全背包问题

• 背包问题 DP

有 N 种物品和一个容量是 V 的背包，每种物品都有无限件可用。

第 i 种物品的体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。

接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 种物品的体积和价值。

输出格式
输出一个整数，表示最大价值。

数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例：
10

#include <iostream>

using namespace std;

const int N = 1010;
int v[N], w[N], f[N];

int main() {
    int n, m;
    cin >> n >> m;
    
    for(int i = 1; i <= n; i ++) {
        int v, w;
        cin >> v >> w;
        
        for(int j = v; j <= m; j ++) {
            f[j] = max(f[j], f[j - v] + w);
        }
    }
    cout << f[m] << endl;
    
    return 0;    
}

#include <iostream>

using namespace std;

const int N = 1010;
int f[N];

int main() {
    int n, m;
    cin >> n >> m;
    for(int i = 0; i < n; i ++) {
        int v, w;
        cin >> v >> w;
        for(int j = 0; j <= m; j ++) {
            for(int k = 0; k * v <= j; k ++) {
                f[j] = max(f[j], f[j - k * v] + k * w);
            }
        }
    }
    cout << f[m] << endl;
    
    return 0;
}

4. 多重背包问题 I

• 背包问题 DP

有 N 种物品和一个容量是 V 的背包。

第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。

输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。

接下来有 N 行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i 种物品的体积、价值和数量。

输出格式
输出一个整数，表示最大价值。

数据范围
0<N,V≤100
0<vi,wi,si≤100
输入样例
4 5
1 2 3
2 4 1
3 4 3
4 5 2
输出样例：
10

#include <iostream>

using namespace std;

const int N = 110;
int f[N];

int main() {
    int n, m;
    cin >> n >> m;
    for(int i = 1; i <= n; i ++) {
        int v, w, s;
        cin >> v >> w >> s;
        for(int j = m; j >= v; j --) { // 从大到小枚举
            for(int k = 0; k <= s && k * v <= j; k ++) {
                f[j] = max(f[j], f[j - k * v] + k * w);
            }
        }
    }
    
    cout << f[m] << endl;
    
    return 0;
}

5. 多重背包问题 II

• 背包问题 DP

有 N 种物品和一个容量是 V 的背包。

第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。

输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。

接下来有 N 行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i 种物品的体积、价值和数量。

输出格式
输出一个整数，表示最大价值。

数据范围
0<N≤1000
0<V≤2000
0<vi,wi,si≤2000
提示：
本题考查多重背包的二进制优化方法。

输入样例
4 5
1 2 3
2 4 1
3 4 3
4 5 2
输出样例：
10

#include <iostream>
#include <vector>

using namespace std;

const int N = 2010;
int f[N];

struct Good {
    int v, w;
};

int main() {
    int n, m;
    cin >> n >> m;
    vector<Good>goods;
    
    for(int i = 1; i <= n; i ++) {
        int v, w, s;
        cin >> v >> w >> s;
        for(int k = 1; k <= s; k *= 2) {
            s -= k;
            goods.push_back({v * k, w * k});
        }
        if(s > 0) goods.push_back({v * s, w * s});
    }
    
    for(auto good : goods) {
        for(int j = m; j >= good.v; j --) {
            f[j] = max(f[j], f[j - good.v] + good.w);
        }
    }
    cout << f[m] << endl;
    
    return 0;
}

9. 分组背包问题

• 背包问题 DP

有 N 组物品和一个容量是 V 的背包。

每组物品有若干个，同一组内的物品最多只能选一个。
每件物品的体积是 vij，价值是 wij，其中 i 是组号，j 是组内编号。

求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。

输出最大价值。

输入格式
第一行有两个整数 N，V，用空格隔开，分别表示物品组数和背包容量。

接下来有 N 组数据：

每组数据第一行有一个整数 Si，表示第 i 个物品组的物品数量；
每组数据接下来有 Si 行，每行有两个整数 vij,wij，用空格隔开，分别表示第 i 个物品组的第 j 个物品的体积和价值；
输出格式
输出一个整数，表示最大价值。

数据范围
0<N,V≤100
0<Si≤100
0<vij,wij≤100
输入样例
3 5
2
1 2
2 4
1
3 4
1
4 5
输出样例：
8

#include <iostream>

using namespace std;

const int N = 110;
int f[N], v[N], w[N];

int main() {
    int n, m;
    cin >> n >> m;
    for(int i = 1; i <= n; i ++) {
        int s;
        cin >> s;
        for(int i = 1; i <= s; i ++){
            cin >> v[i] >> w[i];
        }
        
        for(int j = m; j >= 0; j --) {
            for(int k = 1; k <= s; k ++) {
                if(v[k] <= j)
                    f[j] = max(f[j], f[j - v[k]] + w[k]);
            }
        }
    }
    cout << f[m] << endl;
    return 0;
}

91. 最短Hamilton路径

• 二进制 状态压缩DP

给定一张 n 个点的带权无向图，点从 0~n-1 标号，求起点 0 到终点 n-1 的最短Hamilton路径。 Hamilton路径的定义是从 0 到 n-1 不重不漏地经过每个点恰好一次。

输入格式
第一行输入整数n。

接下来n行每行n个整数，其中第i行第j个整数表示点i到j的距离（记为a[i,j]）。

对于任意的x,y,z，数据保证 a[x,x]=0，a[x,y]=a[y,x] 并且 a[x,y]+a[y,z]>=a[x,z]。

输出格式
输出一个整数，表示最短Hamilton路径的长度。

数据范围
1≤n≤20
0≤a[i,j]≤107
输入样例：
5
0 2 4 5 1
2 0 6 5 3
4 6 0 8 3
5 5 8 0 5
1 3 3 5 0
输出样例：
18

#include <iostream>
#include <cstring>

using namespace std;

const int N = 20, M = 1 << 20;
int f[M][N], w[N][N]; // M种状态 第N个点

int main() {
    int n;
    cin >> n;
    for(int i = 0; i < n; i ++) {
        for(int j = 0; j < n; j ++) {
            cin >> w[i][j];
        }
    }
    memset(f, 0x3f, sizeof(f)); //初始化正无穷
    f[1][0] = 0;
    
    for(int i = 1;i < 1 << n; i ++) {
        for(int j = 0; j < n; j ++) {
            if(i >> j & 1 == 1) { // 检查第j位是不是1
                for(int k = 0; k < n; k ++) {
                    if(i - (1 << j) >> k & 1 == 1) {
                        f[i][j] = min(f[i][j], f[i - (1 << j)][k] + w[k][j]);
                    }
                }
                
            }
        }
    }
    
    cout << f[(1 << n) - 1][n - 1] << endl;
    
    return 0;
}

104. 货仓选址

• 排序 贪心

在一条数轴上有 N 家商店，它们的坐标分别为 A1~AN。

现在需要在数轴上建立一家货仓，每天清晨，从货仓到每家商店都要运送一车商品。

为了提高效率，求把货仓建在何处，可以使得货仓到每家商店的距离之和最小。

输入格式
第一行输入整数N。

第二行N个整数A1~AN。

输出格式
输出一个整数，表示距离之和的最小值。

数据范围
1≤N≤100000
输入样例：
4
6 2 9 1
输出样例：
12

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010;
int f[N];

int main() {
    int n;
    cin >> n;
    for(int i = 1; i <= n; i ++) cin >> f[i];
    sort(f + 1, f + n + 1);
    int mid = f[n / 2 + 1];
    
    int res = 0;
    for(int i = 1; i <= n; i ++) {
        res += abs(f[i] - mid);
    }
    cout << res << endl;
    return 0;
}

125. 耍杂技的牛

• 贪心

农民约翰的N头奶牛（编号为1…N）计划逃跑并加入马戏团，为此它们决定练习表演杂技。

奶牛们不是非常有创意，只提出了一个杂技表演：

叠罗汉，表演时，奶牛们站在彼此的身上，形成一个高高的垂直堆叠。

奶牛们正在试图找到自己在这个堆叠中应该所处的位置顺序。

这N头奶牛中的每一头都有着自己的重量Wi以及自己的强壮程度Si。

一头牛支撑不住的可能性取决于它头上所有牛的总重量（不包括它自己）减去它的身体强壮程度的值，现在称该数值为风险值，风险值越大，这只牛撑不住的可能性越高。

您的任务是确定奶牛的排序，使得所有奶牛的风险值中的最大值尽可能的小。

输入格式
第一行输入整数N，表示奶牛数量。

接下来N行，每行输入两个整数，表示牛的重量和强壮程度，第i行表示第i头牛的重量Wi以及它的强壮程度Si。

输出格式
输出一个整数，表示最大风险值的最小可能值。

数据范围
1≤N≤50000,
1≤Wi≤10,000,
1≤Si≤1,000,000,000
输入样例：
3
10 3
2 5
3 3
输出样例：
2

#include <iostream>
#include <algorithm>
#include <limits.h>

using namespace std;

const int N = 50010;
typedef pair<int, int>PII;
PII cows[N];

int main() {
    int n;
    cin >> n;
    for(int i = 0; i < n; i ++) {
        int w, s;
        cin >> w >> s;
        cows[i] = {w + s, s};
    }
    sort(cows, cows + n);
    int res = INT_MIN, sum = 0;
    for(int i = 0; i < n; i ++) {
        sum -= cows[i].second;
        res = max(res, sum);
        sum += cows[i].first;
    }
    cout << res << endl;
    return 0;
}

143. 最大异或对

• Trie 字典树 贪心

在给定的N个整数A1，A2……AN中选出两个进行xor（异或）运算，得到的结果最大是多少？

输入格式
第一行输入一个整数N。

第二行输入N个整数A1～AN。

输出格式
输出一个整数表示答案。

数据范围
1≤N≤105,
0≤Ai<231
输入样例：
3
1 2 3
输出样例：
3

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010, M = 3000000; //M节点个数

int n;
int son[M][2],idx;
int a[N];

void insert(int x)
{
    int p = 0;
    for(int i = 30; ~i; i--) //i >= 0 等价于 ~i
    {
        int &s = son[p][x >> i & 1]; //取出二进制第i位
        if(!s) s = ++ idx; //创建新节点
        p = s; 
    }
}

int query(int x)
{
    int res = 0, p = 0;
    for(int i = 30; ~i; i--)
    {
        int s = x >> i & 1;
        if(son[p][!s]) //查看不一样的分支是否存在 1看0 0看1
        {
            res += 1 << i; //当前位对res所做出的贡献
            p = son[p][!s];
        }
        else p = son[p][s];
    }
    return res;
}

int main()
{
    cin >> n;
    for(int i = 0; i < n; i++) 
    {
        cin >> a[i];
        insert(a[i]);
    }
    int res = 0;
    for(int i = 0; i < n; i++) res = max(res, query(a[i])); //query 找到和当前异或最大的结果  
            
    cout << res << endl;
    return 0;
}

#include <iostream>

using namespace std;

const int N = 100010, M = 30000000; //节点数目
int a[N], son[M][2], idx;

void insert(int x) {
    int p = 0;
    for(int i = 30; i >= 0; i --) {
        int s = x >> i & 1;
        if(!son[p][s]) son[p][s] = ++idx;
        p = son[p][s];
    }
}

int query(int x) {
    int res = 0, p = 0;
    for(int i = 30; i >= 0; i --) {
        int s = x >> i & 1;
        if(son[p][!s]) {
            res += 1 << i;
            p = son[p][!s];
        } else {
            p = son[p][s];
        }
    }
    return res;
}

int main() {
    int n;
    cin >> n;
    for(int i = 0; i < n; i ++) {
        cin >> a[i];
        insert(a[i]);
    }
    int res = 0;
    for(int i = 0; i < n; i ++) {
        res = max(res, query(a[i]));
    }
    cout << res << endl;
    
    return 0;
}

148. 合并果子

• 贪心 二叉堆 Huffman树(叶子结点权值*叶子节点到根的距离的总和)

在一个果园里，达达已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。

达达决定把所有的果子合成一堆。

每一次合并，达达可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。

可以看出，所有的果子经过n-1次合并之后，就只剩下一堆了。

达达在合并果子时总共消耗的体力等于每次合并所耗体力之和。

因为还要花大力气把这些果子搬回家，所以达达在合并果子时要尽可能地节省体力。

假定每个果子重量都为1，并且已知果子的种类数和每种果子的数目，你的任务是设计出合并的次序方案，使达达耗费的体力最少，并输出这个最小的体力耗费值。

例如有3种果子，数目依次为1，2，9。

可以先将1、2堆合并，新堆数目为3，耗费体力为3。

接着，将新堆与原先的第三堆合并，又得到新的堆，数目为12，耗费体力为12。

所以达达总共耗费体力=3+12=15。

可以证明15为最小的体力耗费值。

输入格式
输入包括两行，第一行是一个整数n，表示果子的种类数。

第二行包含n个整数，用空格分隔，第i个整数ai是第i种果子的数目。

输出格式
输出包括一行，这一行只包含一个整数，也就是最小的体力耗费值。

输入数据保证这个值小于231。

数据范围
1≤n≤10000,
1≤ai≤20000
输入样例：
3
1 2 9
输出样例：
15

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

int main() {
    int n;
    cin >> n;
    priority_queue<int, vector<int>, greater<int>>heap;
    for(int i = 0; i < n; i ++) {
        int x;
        cin >> x;
        heap.push(x);
    }
    int res = 0;
    while(heap.size() > 1) {
        int a = heap.top(); heap.pop();
        int b = heap.top(); heap.pop();
        int c = a + b;
        res += c;
        heap.push(c);
    }
    cout << res << endl;
    
    return 0;
}