数位区间DP+组合数学
hdu2089：数位dp
不要62
Time Limit: 1000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 91160 Accepted Submission(s): 38144
Problem Description
杭州人称那些傻乎乎粘嗒嗒的人为62（音：laoer）。
杭州交通管理局经常会扩充一些的士车牌照，新近出来一个好消息，以后上牌照，不再含有不吉利的数字了，这样一来，就可以消除个别的士司机和乘客的心理障碍，更安全地服务大众。
不吉利的数字为所有含有4或62的号码。例如：
62315 73418 88914
都属于不吉利号码。但是，61152虽然含有6和2，但不是62连号，所以不属于不吉利数字之列。
你的任务是，对于每次给出的一个牌照区间号，推断出交管局今次又要实际上给多少辆新的士车上牌照了。
Input
输入的都是整数对n、m（0<n≤m<1000000），如果遇到都是0的整数对，则输入结束。
Output
对于每个整数对，输出一个不含有不吉利数字的统计个数，该数值占一行位置。
Sample Input
1 100
0 0
Sample Output
80
代码
这题在hdu暴力能过
暴力写法
#include<iostream>
#include<string>
#include<vector>
using namespace std;
const int N = 1000001;
int nums[N] = { 0 };
int main()
{
string num;
int l, r;
for (int i = 1; i < N; i++)
{
num = to_string(i);
bool flag = true;
for (int i = 0; i < num.size(); i++)
{
if (i < num.size() - 1)
if (num[i] == '6' && num[i + 1] == '2')
{
flag = false;
break;
}
if (num[i] == '4')
{
flag = false;
break;
}
}
if (flag)
nums[i] = nums[i - 1] + 1;
else
nums[i] = nums[i - 1];
}
while (cin >> l >> r && (l || r))
{
cout << nums[r] - nums[l - 1] << endl;
}
return 0;
}
数位dp
调bug调个半死,dp[i ] [j]表示i位数首位是j的时符合要求的个数
#include<stdio.h>
#include<algorithm>
#include<string>
#include<cstring>
#include<math.h>
#include<vector>
#include<queue>
#include<stack>
#include<list>
#include<map>
#include<set>
#include<unordered_map>
#include<unordered_set>
#include<iostream>
using namespace std;
const int maxn = 1e6 + 10;
int dp[10][10] = { 0 };
int num[maxn] = { 0 };
void init()
{
dp[0][0] = 1;
for (int i = 1; i <= 7; i++)
for (int j = 0; j <= 9; j++)
for (int k = 0; k <= 9; k++)
if (j != 4)
if (i == 1 || i >= 2 && (j != 6 || k != 2))
dp[i][j] += dp[i - 1][k];
}
int solve(int n)
{
if (num[n])
return num[n];
int len = 0, x = n;
int digit[10] = { 0 };
while (n)
{
digit[++len] = n % 10;
n /= 10;
}
int ans = 0;
for (int i = len; i >= 1; i--)
{
for (int j = 0; j < digit[i]; j++)
if(j!=4&&(j!=2||digit[i+1]!=6))/*尤其注意这个地方，我调试了2个多小时才发现这个地方没有写
最后还是拿暴力写法对比数据搞出来的，j!=4可写可不写，因为j为4时dp[i][j]是0*/
ans += dp[i][j];
if (digit[i] == 4 || i<len&&(digit[i+1] == 6 && digit[i] == 2))//注意是digit[i]为2，才会舍弃后面的
{
ans--;//把多算的0去除需要-1，但如果到了digit[1]也满足条件，
//可digit[i]没有被计算需要加一，刚好抵消，这时不要执行此语句
break;
}
}
num[x] = ans;
return ans;
}
int main()
{
int n, m;
init();
while (cin >> n >> m && (n || m))
{
cout << solve(m) - solve(n - 1) << endl;
}
return 0;
}
hdu3555：数位dp
Bomb
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 131072/65536 K (Java/Others)Total Submission(s): 33838 Accepted Submission(s): 13001
Problem Description
The counter-terrorists found a time bomb in the dust. But this time the terrorists improve on the time bomb. The number sequence of the time bomb counts from 1 to N. If the current number sequence includes the sub-sequence “49”, the power of the blast would add one point.
Now the counter-terrorist knows the number N. They want to know the final points of the power. Can you help them?
Input
The first line of input consists of an integer T (1 <= T <= 10000), indicating the number of test cases. For each test case, there will be an integer N (1 <= N <= 2^63-1) as the description.
The input terminates by end of file marker.
Output
For each test case, output an integer indicating the final points of the power.
Sample Input
3
1
50
500
Sample Output
0
1
15
Hint
From 1 to 500, the numbers that include the sub-sequence “49” are “49”,“149”,“249”,“349”,“449”,“490”,“491”,“492”,“493”,“494”,“495”,“496”,“497”,“498”,“499”,
so the answer is 15.
代码
数据范围比较大，只能数位dp了，dp数组要开到20左右
细心啊各位，实参是ll，传给了int的形参，找了半天，服了
#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<string>
#include<cstring>
#include<math.h>
#include<vector>
#include<queue>
#include<stack>
#include<list>
#include<map>
#include<set>
#include<unordered_map>
#include<unordered_set>
#include<iostream>
using namespace std;
typedef long long ll;
const ll maxn = 9223372036854775807i64;
ll dp[30][10] = { 0 };//dp[i][j]表示第i位为j符合要求的个数,从0位开始
ll ten[20]={1};
void init()
{
for (int i = 1; i <= 19; i++)
ten[i] = 10 * ten[i - 1];
for(int i=1;i<=19;i++)
for(int j=0;j<=9;j++)
for (int k = 0; k <= 9; k++)
{
if (j == 4 && k == 9)
dp[i][j] += ten[i-1];
else
dp[i][j] += dp[i - 1][k];
}
}
ll solve(ll n)
{
int digit[30] = { 0 };
int len = -1;
ll ans = 0;
while (n)
{
digit[++len] = n % 10;
n /= 10;
}
for (int i = len; i >= 0; i--)
{
for (int j = 0; j < digit[i]; j++)
{
/*if (i < len && j == 9 && digit[i + 1] == 4)
ans += ten[i];
else*/
//j不会出现9
ans += dp[i][j];
}
if (i<len&&digit[i] == 9 && digit[i + 1] == 4)
{
for (int j = i-1; j >= 0; j--)
ans +=ten[j]*digit[j];
ans += 1;//注意后面全部是0的情况要加上
break;
}
}
return ans;
}
int main()
{
ll t, n;
init();
cin >> t;
while (t--)
{
cin >> n;
cout << solve(n) << endl;
}
}
本来今天想要好好把数位dp搞了的，被一个题卡了，先放着明天再更，今天水一个区间dp
洛谷p1880：区间dp
[NOI1995] 石子合并
题目描述
在一个圆形操场的四周摆放 N N N 堆石子，现要将石子有次序地合并成一堆，规定每次只能选相邻的 2 2 2 堆合并成新的一堆，并将新的一堆的石子数，记为该次合并的得分。
试设计出一个算法,计算出将 N N N 堆石子合并成 1 1 1 堆的最小得分和最大得分。
输入格式
数据的第 1 1 1 行是正整数 N N N，表示有 N N N 堆石子。
第 2 2 2 行有 N N N 个整数，第 i i i 个整数 a i a_i ai 表示第 i i i 堆石子的个数。
输出格式
输出共 2 2 2 行，第 1 1 1 行为最小得分，第 2 2 2 行为最大得分。
样例 #1
样例输入 #1
4
4 5 9 4
样例输出 #1
43
54
提示
1 ≤ N ≤ 100 1\leq N\leq 100 1≤N≤100， 0 ≤ a i ≤ 20 0\leq a_i\leq 20 0≤ai≤20。
代码
石子合并问题加强版，加了个环绕，与其当成环不如把数组扩大一倍，这样就可以达到循环了，最后只要找长度为n的最大或最小就行
区间dp的四边形不等式优化还没看懂证明先就不这么写
#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<string>
#include<cstring>
#include<math.h>
#include<vector>
#include<queue>
#include<stack>
#include<list>
#include<map>
#include<set>
#include<unordered_map>
#include<unordered_set>
#include<iostream>
using namespace std;
const int INF = 1 << 30;
const int N = 110;
int sum[N*2],nums[N*2],n;
int dp1[2*N][2*N];
int dp2[2*N][2*N];
int minval()
{
for (int i = 1; i <=2* n; i++)
dp1[i][i] = 0;
for(int len=1;len<n;len++)
for (int i = 1; i <= 2*n-len; i++)
{
int j = i + len;
dp1[i][j] = INF;
for (int k = i; k < j; k++)
dp1[i][j] = min(dp1[i][j], dp1[i][k] + dp1[k + 1][j] + sum[j] - sum[i - 1]);//以k为分界线，合并两堆已经被合并的石子，合并i到j的最小花费
}
int ans = INF;
for (int i = 1; i <= n; i++)
ans = min(dp1[i][i + n - 1], ans);
return ans;
}
int maxval()
{
for (int i = 1; i <=2* n; i++)
dp2[i][i] = 0;
for (int len = 1; len < n; len++)
for (int i = 1; i <= 2*n-len; i++)
{
int j = i + len;
dp2[i][j] = -1;
for (int k = i; k < j; k++)
dp2[i][j] = max(dp2[i][j], dp2[i][k] + dp2[k + 1][j] + sum[j] - sum[i - 1]);//以k为分界线，合并两堆已经被合并的石子，合并i到j的最大花费
}
int ans = -1;
for (int i = 1; i <= n; i++)
ans = max(dp2[i][i + n - 1], ans);
return ans;
}
int main()
{
cin >> n;
for (int i = 1; i <= n; i++)
{
cin >> nums[i];
nums[i + n] = nums[i];
}
for (int i = 1; i <= 2 * n; i++)
{
sum[i] = sum[i - 1] + nums[i];
}
cout << minval() << endl;
cout<< maxval() << endl;
return 0;
}
今天看了下蓝桥杯真题，发现组合数学的知识有点忘了，这里补一下
hdu1205：鸽巢原理
吃糖果
Time Limit: 6000/3000 MS (Java/Others) Memory Limit: 65535/32768 K (Java/Others)Total Submission(s): 68228 Accepted Submission(s): 19497
Problem Description
HOHO，终于从Speakless手上赢走了所有的糖果，是Gardon吃糖果时有个特殊的癖好，就是不喜欢将一样的糖果放在一起吃，喜欢先吃一种，下一次吃另一种，这样；可是Gardon不知道是否存在一种吃糖果的顺序使得他能把所有糖果都吃完？请你写个程序帮忙计算一下。
Input
第一行有一个整数T，接下来T组数据，每组数据占2行，第一行是一个整数N（0<N<=1000000)，第二行是N个数，表示N种糖果的数目Mi(0<Mi<=1000000)。
Output
对于每组数据，输出一行，包含一个"Yes"或者"No"。
Sample Input
2
3
4 1 1
5
5 4 3 2 1
Sample Output
No
Yes
Please use function scanf
代码
找出最多的糖果，数量n，把n个糖果看成n个挡板，当其他糖果的和大于等于n-1时必然有解，我们只需要把s个糖果排成一队，注意所有相同的糖果要挨着，然后每次取n个糖果，隔着隔板放就行。如果其他糖果和小于n-1就必然有最多的那种糖果相邻
注意下和的数据范围就行了
#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<string>
#include<cstring>
#include<math.h>
#include<vector>
#include<queue>
#include<stack>
#include<list>
#include<map>
#include<set>
#include<unordered_map>
#include<unordered_set>
#include<iostream>
using namespace std;
int n;
int main()
{
int t;
scanf("%d", &t);
while (t--)
{
scanf("%lld", &n);
long long sum = 0,m=0,x;
for (int i = 0; i < n; i++)
{
scanf("%lld", &x);
sum += x;
m = max(m, x);
}
if (sum - m < m - 1)
puts("No");
else
puts("Yes");
}
return 0;
}
杨辉三角
杨辉三角形的第n行第k项可以用二项式表示为C(n,k)，证明采用(1+x)^n的展开式，注意二项式的计算，可以表示位(k+1)/1*(k+2)/2…n/k；这样会最大限度减少溢出问题，同时也不会出现下取整问题
Catalan数
模型很简单：n个1和n个0排成一行，使任意前k个数中1的数量大于0的个数或者0的个数大于1的个数，有多少种方案，最终答案为C(2n,n)/(n+1),但是需要注意证明。
[NOIP2003 普及组] 栈
题目背景
栈是计算机中经典的数据结构，简单的说，栈就是限制在一端进行插入删除操作的线性表。
栈有两种最重要的操作，即 pop（从栈顶弹出一个元素）和 push（将一个元素进栈）。
栈的重要性不言自明，任何一门数据结构的课程都会介绍栈。宁宁同学在复习栈的基本概念时，想到了一个书上没有讲过的问题，而他自己无法给出答案，所以需要你的帮忙。
题目描述
宁宁考虑的是这样一个问题：一个操作数序列， 1 , 2 , … , n 1,2,\ldots ,n 1,2,…,n（图示为 1 到 3 的情况），栈 A 的深度大于 n n n。
现在可以进行两种操作，
- 将一个数，从操作数序列的头端移到栈的头端（对应数据结构栈的 push 操作）
- 将一个数，从栈的头端移到输出序列的尾端（对应数据结构栈的 pop 操作）
使用这两种操作，由一个操作数序列就可以得到一系列的输出序列，下图所示为由 1 2 3 生成序列 2 3 1 的过程。
（原始状态如上图所示）
你的程序将对给定的 n n n，计算并输出由操作数序列 1 , 2 , … , n 1,2,\ldots,n 1,2,…,n 经过操作可能得到的输出序列的总数。
输入格式
输入文件只含一个整数 n n n（ 1 ≤ n ≤ 18 1 \leq n \leq 18 1≤n≤18）。
输出格式
输出文件只有一行，即可能输出序列的总数目。
样例 #1
样例输入 #1
3
样例输出 #1
5
提示
【题目来源】
NOIP 2003 普及组第三题
代码
标准卡特兰数，入栈必须大于出栈
这题也可以dp做
#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<string>
#include<cstring>
#include<math.h>
#include<vector>
#include<queue>
#include<stack>
#include<list>
#include<map>
#include<set>
#include<unordered_map>
#include<unordered_set>
#include<iostream>
using namespace std;
long long C(long long n, long long m)
{
long long ans = 1;
for (int i = 1; i <= m; i++)
{
ans = ans*(n - m + i) / i;
}
return ans;
}
int main()
{
int n;
cin >> n;
cout << C(2 * n, n) / (n + 1) << endl;
return 0;
}
**
787
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
