文章目录
——2020年11月22日（周日）——————————————————
#数位DP
一、计数问题
题目链接
第一次做真的很难，总之十分耗费时间。
第一次批注得这么满……
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
const int N = 10;
//get前面前缀部分的数值，即前面前缀总方案数
int get(vector<int> num, int l, int r)
{
int res = 0;
for (int i = l; i >= r; i -- ) res = res * 10 + num[i];
return res;
}
//后缀有几位就是十的几次方
int power10(int x)
{
int res = 1;
while (x -- ) res *= 10;
return res;
}
//这是1到n中i出现的次数
int count(int n, int x){
//0的话就不要讨论了
if (!n) return 0;
//将n的每一位都拆下来
vector<int> num;
while (n){
num.push_back(n % 10);
n /= 10;
}
n = num.size();
//接下来是统计在当前位置上取某个数会有多少种方案
int res = 0;
/*
首先要明白，x是指在这一位取x，然后去求总共的方案数
x等于0的时候要另行讨论！
i从最高位开始枚举，枚举的是第i位出现了x的次数
*/
/*
这里假设这个序列式abcdefg,现在i在中间位置d,其前缀是abc, 后缀是efg
一、这是第i位的前缀 小于 abc 的情况（当然，首先这个位置得有前缀才可以）
000~abc - 1, 999种（也可以说是 10的i-1的次方 - 1 种）；
二、这是前缀等于abc的情况,记住！前提是前缀相等！
这里分别讨论第i位的三种情况，因为这三种情况对应了不同的三种后缀的情况！
1. 第i位 大于 目标最大值的第i位，那么后缀根本取不了，也就是0种情况。
2. 第i位 等于 目标最大的第i位
此时后缀可以随便取，于是有0~efg这些情况
num[i] == x, 0~efg
3. 第i位 小于 目标最大的第i位
此时后面的位置可以随便取，有1000种情况
num[i] > x, 0~999（也就是0 ~ 10的i-1的次方 - 1 种 情况）
*/
for (int i = n - 1 - !x; i >= 0; i -- ){
//如果i所在的不是最高位,那么就会有前缀，那么我们就来先处理前缀小于abc的情况
if (i < n - 1){
//res += 前缀的值 * 10的后缀的次方
//这里前缀的情况应该是0~前缀（abc）-1，一共abc种情况，并没有把abc这种情况也算进去
res += get(num, n - 1, i + 1) * power10(i);
//如果x是0的话，前缀里面会少一种情况（就是这个情况：0...0，因为想要这一位取0，那么前缀不可能全是0）；
//比如三位数里想要第二位取0，那么就可以有102,103,106……但是绝对不会有002,003,006……等情况存在，不是吗？
if (!x) res -= power10(i);
}
//然后我们来处理前缀就是abc的情况，当然啦，这里就不管有没有前缀了，都一样的~
//当前要取的数x 与 目标最大值的这一位数相等的时候 ，就是后面构成的数再加1（0这种情况）
if (num[i] == x) res += get(num, i - 1, 0) + 1;
//当前要取的数x 小于 目标最大值的这一位数 的时候，只要加上十的后面的数的位数的次方
else if (num[i] > x) res += power10(i);
}
return res;
}
int main()
{
int a, b;
while (cin >> a >> b , a){
//保证a小于b
if (a > b) swap(a, b);
//分位置来讨论 每一位上 取 某一个数 会有多少种情况
for (int i = 0; i <= 9; i ++ )
cout << count(b, i) - count(a - 1, i) << ' ';
cout << endl;
}
return 0;
}
明天大概会搞定蒙德里安那道题吧……
——2020年11月23日（周一）——————————————————
#状压DP
一、蒙德里安的梦想
之前写的笔记因为某种原因丢失了QwQ……心疼
不过还好脑子里还有点记忆……
推荐这位大佬的笔记。链接
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 13, M = 1 << N;
ll dp[N][M];
bool st[M];
int main() {
int n, m;
while (cin >> n >> m && n != 0) {
//预处理一下，所有的状态是否不存在连续奇数个0
//遍历所有的状态
for (int i = 0; i < (1 << n); i++) {
//假设是成立的
st[i] = true;
//cnt是当前这一段连续0的个数
int cnt = 0;
//n是这个二进制数的位数
for (int j = 0; j < n; j++) {
//如果当前这一位是1，说明上一段已经截止了
if (i >> j & 1) {
//判断上一段连续的0是否是奇数个，若是
if (cnt & 1) {
//说明第i个状态时不合法的，存在了连续奇数个0
st[i] = false;
}
//遇到1以后，连续奇数个0已经结束了，新开始一段
cnt = 0;
}
else cnt++;
}
//然后判断最后一段0的个数
if (cnt & 1) {
st[i] = false;
}
}
//然后是dp的过程
//把dp数组重置为0
memset(dp, 0, sizeof dp);
//边界情况，即第0行状态是0的时候有一个方案（方便后面进行转移）
dp[0][0] = 1;
//枚举所有的列
for (int i = 1; i <= m; i++) {
//枚举第i列的所有状态
for (int j = 0; j < (1 << n); j++) {
//再枚举第i - 1列的所有状态
for (int k = 0; k < (1 << n); k++) {
//确保状态两两之间是不冲突的。并且它们加起来之后得到的当前一行是合法的。
//就是说，将上一行伸出来的头插到这一行里面吻合合法状态
if ((j & k) == 0 && st[j | k]) {
dp[i][j] += dp[i - 1][k];
}
}
}
}
//答案
cout << dp[m][0] << endl;
}
return 0;
}
这个是遗留下来的……做个纪念。
#include<bits/stdc++.h>
using namespace std;
const int N = 12, M = 1 << N;
int n, m;
//这里存的是到第i行的某个状态的总方案数
long long f[N][M];
//存的是所有的合法状态state
vector<int> state[M];
//判断当前这一列能不能用小方块填满,也就是当前状态下0的个数是不是偶数个
//连通性问题！！！！
bool st[M];
int main()
{
while (cin >> n >> m, n || m)
{
//预处理
for (int i = 0; i < 1 << n; i ++ )
{
//cnt表示0的个数
int cnt = 0;
st[i] = true;
//横着做，每行会有n个数
for (int j = 0; j < n; j ++ )
//如果当前这一位是1的话，那就判断前面的0是不是偶数个
if (i >> j & 1)
{
//如果是奇数个，那么就是不合法的
if (cnt & 1) st[i] = false;
//cnt要清空成0
cnt = 0;
}
//如果是0就cnt++
else cnt ++ ;
//要判断最后一段0
if (cnt & 1) st[i] = false;
}
//这里预处理某一列的上一列对应的所有情况的合法状态，极大地减少了时间
for(int i = 0; i < 1 << n; i ++){
//清空上一轮的数据
state[i].clear();
//所有情况都枚举一遍
for(int j = 0; j < 1 << n; j ++)
//如果两个状态不冲突 且 他们合并后的状态可以被竖着的小方块填满，也就是合法
if((i & j) == 0 && st[i | j])
state[i].push_back(j);
}
//记得是多组数据，要先清空之前的数据
memset(f, 0, sizeof f);
f[0][0] = 1;
//挨列解决该列每一种情况的方案
for(int i = 1 ;i <= m; i ++)
//枚举这2的n次方种情况
for(int j = 0; j < 1 << n; j ++)
//这里直接枚举对应的所有合法情况，这就是上面提到的优化！
for(auto k : state[j])
f[i][j] += f[i - 1][k];
cout << f[m][0] << endl;
}
return 0;
}
纯净版代码
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 13, M = 1 << N;
ll dp[N][M];
bool st[M];
int main() {
int n, m;
while (cin >> n >> m && n != 0)
{
for (int i = 0; i < (1 << n); i++)
{
st[i] = true;
int cnt = 0;
for (int j = 0; j < n; j++)
{
if (i >> j & 1)
{
if (cnt & 1)
{
st[i] = false;
}
cnt = 0;
}
else cnt++;
}
if (cnt & 1)
{
st[i] = false;
}
}
memset(dp, 0, sizeof dp);
dp[0][0] = 1;
for (int i = 1; i <= m; i++)
{
for (int j = 0; j < (1 << n); j++)
{
for (int k = 0; k < (1 << n); k++)
{
if ((j & k) == 0 && st[j | k])
{
dp[i][j] += dp[i - 1][k];
}
}
}
}
cout << dp[m][0] << endl;
}
return 0;
}
——2020年11月24日（周二）——————————————————
#背包问题
一、数字组合
一时间没有反应过来……
原题链接
#include<bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int n, m;
//这个既是体积又是价值
int v[N];
//方案数,方案数的转移方程是 f[j] += f[j - v[i]];
int f[N];
int main(){
cin >> n >> m;
for(int i = 1; i <= n; i ++) scanf("%d", &v[i]);
//初始化
f[0] = 1;
//枚举物品,这里要避免重复
for(int i = 1; i <= n; i ++)
for(int j = m; j >= v[i]; j --)
f[j] += f[j - v[i]];
cout << f[m];
return 0;
}
再来看看自己六个月前写的代码
#include<bits/stdc++.h>
using namespace std;
int main(){
int N, M, f[10010];
cin >> N >> M ;
f[0] = 1;
while(N --){
int v;
cin >> v;
for ( int j = M; j >= v; j --){
f[j ] += f[j - v];
}
}
cout << f[M];
return 0;
}
半年前的代码比这个好多了……惭愧。
于是再来重写一遍，提醒自己以后交代码不要那么草率，能优化的就优化。
#include<bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int n, m;
//方案数,方案数的转移方程是 f[j] += f[j - v[i]];
int f[N];
int main(){
f[0] = 1;
cin >> n >> m;
for(int i = 1; i <= n; i ++){
int v; cin >> v;
for(int j = m; j >= v; j --)
f[j] += f[j - v];
}
cout << f[m];
return 0;
}
二、自然数拆分
题目链接
有点小失误。
第一次：发现最后输出有问题，原因是忘了输出的时候将方案数减1；
第二次：发现忘记了mod；
第三次：发现数组类型开小了，要long long；
总之还是不够细……
#include<bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10, M = 2147483648;
typedef long long ll;
//本题的状态转移方程：f[j] += f[j - i];
ll f[N];
int main(){
f[0] = 1;
int n; cin >> n;
for(int i = 1; i <= n; i ++){
//本题是可以重复计算的，于是从小到大枚举
for(int j = i; j <= n; j ++)
f[j] = (f[j] + f[j - i]) % M;
}
//这里减1是因为题目要求这个数至少分成两个自然数，于是拆分成n自己的这一个方案不算。
cout << f[n] - 1;
return 0;
}
三、完全背包
第一层次：将每次输入的数据看作是s个体积为v价值为w的物品，对这个物品进行s次01背包的操作。
第一层次的题目链接
方法有点笨却是最容易想到的 。时间相对的也很高。
#include<bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int f[N];
int main(){
int n, m; cin >> n >> m;
for(int i = 1; i <= n; i ++){
int v, w, s;
scanf("%d%d%d", &v, &w, &s);
for(int k = 1; k <= s; k ++){
for(int j = m; j >= v; j --)
f[j] = max(f[j], f[j - v] + w);
}
}
cout << f[m];
return 0;
}
然后是第二层次:
题目链接
主要就是在拆分的时候将无脑拆分变为高效的二进制拆分。
因为二进制拆分的话，可以自由组合成1~s内任意数量的数，
01背包DP会选择最优解，也就是最合适的数量方案会被保留下来。
#include<bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
int f[N];
int main(){
int n, m; cin >> n >> m;
for(int i = 1; i <= n; i ++){
int w, v, s;
scanf("%d%d%d", &v, &w, &s);
//二进制优化!同样是拆分成k个不同的物体进行01背包的操作
int k = 1;
//这里的二进制拆分我直接和背包DP合二为一了
//没必要再开一个数组储存拆分后的k个物品的价值和体积，浪费空间.
while(k <= s){
int V = v * k, W = w * k;
for(int j = m; j >= V; j --)
f[j] = max(f[j], f[j - V] + W);
s -= k;
k *= 2;
}
//不要忘了s剩下的值！！！
if(s){
int V = v * s, W = w * s;
for(int j = m; j >= V; j --)
f[j] = max(f[j], f[j - V] + W);
}
}
cout << f[m];
return 0;
}
四、分组背包
题目链接
感觉就是刚学的时候难想到思路，一旦学会了一辈子也不会忘吧……
无非就是将01背包里枚举物品的循环 和 枚举体积的循环 反过来嘛，
这样可以制造一个多选一的效果以保证同一组被的物品不被重复选择。
#include<bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
int f[N];
int v[N], w[N];
int main(){
int t, m; cin >> t >> m;
while(t --){
int n; cin >> n;
for(int i = 1; i <= n; i ++) scanf("%d%d", &v[i], &w[i]);
//不重复！这里枚举体积要注意
for(int j = m; j >= 1; j --)
//然后才是枚举物品，这样做可以让一组之内的物品不会被重复选用
for(int i = 1; i <= n; i ++)
if(j >= v[i]) f[j] = max(f[j], f[j - v[i]] + w[i]);
}
cout << f[m];
return 0;
}
——————————————__——___——简单的题就到此为止了……接下来是两道困难题，今天很可能切不掉……
五、硬币
题目链接
男人……八题？？
——2020年11月25日（周三）——————————————————
难言之隐……
——2020年11月26日（周四）——————————————————
完全背包
一、陪审团（只是来自《算法进阶指南》的笔记）
题目链接
好难啊啊！！！原本觉得自己可以徒手切个中等题的
首先是来自进阶指南的笔记：
这是一个有多个体积维度的01背包。把N个候选人看作是N个物品，每个物品有以下三种体积：
- “人数”，每个候选人都占一个人数。
- “辩方得分”：辩方打分——
a[i]—— 一个0~20的整数。 - “控方得分”：控方打分——
b[i]—— 一个0~20的整数。
此时用一个Bool 数组F[j, d, p]表示已有j人被选入陪审团，当前辩方总分为d、控方总分为p的状态是否可行。
状态转移：F[j, d, p] = F[j, d, p] or F[ j, d - a[i], p - b[i] ]；
初始化：F[0,0,0] = true,其余为false.
目标：找到一个状态F[m,d,p] = true且|d - p|尽量小的同时d + p尽量大 。
当然，这个办法并不是最好的：没有很好地利用背包价值这一维度。
我们可以将a[i] - b[i]看作是物品的体积之一，a[i] + b[i]作为价值。
当外层循环到i的时候，让f[j, k]表示已经在前i个候选人中选择了j人，此时双方总分的差值在为k时双方总分的最大值。
状态转移：f[j, k] = max( f[j, k], f[ j - 1, k - ( a[ i ] - b[ i ] ) ] + a[ i ] + b[ i ] ),
初始化： f[0, 0] = 0，其余为负无穷。
目标：找到一个状态f[ m, k ]满足|k|尽量小，且m = | k |时其f[m, k ]尽量大。
本题最难办的地方：输出具体方案。
采用记录转移路径的办法， 额外建立一个数组D，其中D[i , j, k ]表示外层循环到 i 时状态F[j, k]是选择了哪一位候选人得来的。
这里必须采用三维数组, 因为后续的i可能会覆盖之前的D[i, j, k]保存的值。求得最优解后，可以沿着D记录的路径转移，得到方案。
设Last = D[i, j, k],不断从（i, j, k）递归到(last - 1, j - 1, k - (a[last] - b[last]) )直到j = 0.
——2020年11月27日（周五）——————————————————
完全背包
一、陪审团
没做出来呢……计划被推后了……遗憾。
——2020年11月28日（周六）——————————————————
没有笔记哦~
1351
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
