[kuangbin带你飞]专题十五 数位DP

最新推荐文章于 2020-11-25 23:57:49 发布
最新推荐文章于 2020-11-25 23:57:49 发布
阅读量342 收藏 1
点赞数
分类专栏： DP 文章标签： kuangbin带你飞专题十五 数位DP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Egqawkq/article/details/78290885
版权 
A	CodeForces 55D	Beautiful numbers

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;

const int MAXN = 25;
const int MOD = 2520;//1~9的lcm为2520
long long dp[MAXN][MOD][48];
int index[MOD + 10];//记录1~9的最小公倍数
int bit[MAXN];

int lcm(int a, int b)
{
	return a / __gcd(a, b)*b;
}

void init()
{
	int num = 0;
	for (int i = 1; i <= MOD; i++)
		if (MOD%i == 0)
			index[i] = num++;
}

long long dfs(int pos, int preSum, int preLcm, bool flag)
{
	if (pos == -1)
		return preSum%preLcm == 0;
	if (!flag && dp[pos][preSum][index[preLcm]] != -1)
		return dp[pos][preSum][index[preLcm]];
	long long ans = 0;
	int end = flag ? bit[pos] : 9;//上界
	for (int i = 0; i <= end; i++)
	{
		int nowSum = (preSum * 10 + i) % MOD;
		int nowLcm = preLcm;
		if (i)nowLcm = lcm(nowLcm, i);
		ans += dfs(pos - 1, nowSum, nowLcm, flag && i == end);
	}
	if (!flag)
		dp[pos][preSum][index[preLcm]] = ans;
	return ans;
}

long long calc(long long x)
{
	int pos = 0;
	while (x)
	{
		bit[pos++] = x % 10;
		x /= 10;
	}
	return dfs(pos - 1, 0, 1, 1);
}

int main()
{
	int T;
	long long l, r;
	init();
	memset(dp, -1, sizeof(dp));
	scanf("%d", &T);
	while (T--)
	{
		scanf("%lld%lld", &l, &r);
		printf("%lld\n", calc(r) - calc(l - 1));
	}
	return 0;
}





B	HDU 4352	XHXJ's LIS

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define LL long long
using namespace std;

LL dp[20][1 << 10][11];
int k, bit[20];

int update(int x, int s)
{
	for (int i = x; i<10; i++)
	{
		if (s&(1 << i))
			return (s ^ (1 << i)) | (1 << x);
	}
	return s | (1 << x);
}

int getK(int s)
{
	int cnt = 0;
	while (s)
	{
		if (s & 1)cnt++;
		s >>= 1;
	}
	return cnt;
}

LL dfs(int pos, int s, bool e, bool z) //e为上界，z记录前面的是否都为0,1代表全为0
{
	if (!pos)
		return getK(s) == k;
	if (!e && dp[pos][s][k] != -1)
		return dp[pos][s][k];
	int digit = e ? bit[pos] : 9;
	LL ans = 0;
	for (int i = 0; i <= digit; i++)
	{
		ans += dfs(pos - 1, (z && (i == 0)) ? 0 : update(i, s), e&&i == digit, z && (i == 0));
	}
	if (!e)dp[pos][s][k] = ans;
	return ans;
}

LL solve(LL n)
{
	int len = 0;
	while (n)
	{
		bit[++len] = n % 10;
		n /= 10;
	}
	return dfs(len, 0, 1, 1);
}

int main()
{
	int cas = 1, t;
	scanf("%d", &t);
	memset(dp, -1, sizeof dp);
	while (t--)
	{
		LL a, b;
		cin >> a >> b >> k;
		printf("Case #%d: %I64d\n", cas++, solve(b) - solve(a - 1));
	}
	return 0;
}





HDU 2089	不要62

#include<iostream>
#include<cstdio>
using namespace std;

int dp[10][10];
int d[10];

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 && !(j == 6 && k == 2))
					dp[i][j] += dp[i - 1][k];
}

int solve(int n)
{
	int ans = 0;
	int len = 0;
	while (n)
	{
		++len;
		d[len] = n % 10;
		n /= 10;
	}
	d[len + 1] = 0;
	for (int i = len; i >= 1; --i)
	{
		for (int j = 0; j < d[i]; ++j)
		{
			if (d[i + 1] != 6 || j != 2)
				ans += dp[i][j];
		}
		if (d[i] == 4 || (d[i + 1] == 6 && d[i] == 2))
			break;
	}
	return ans;
}

int main()
{
	int m, n;
	init();
	while (scanf("%d%d", &m, &n) == 2)
	{
		if (n == 0 && m == 0) break;
		printf("%d\n", solve(n + 1) - solve(m));
	}
	return 0;
}





D	HDU 3555	Bomb

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef __int64 LL;
LL dp[27][3];
int c[27];
//dp[i][j]:长度为i的数的第j种状态
//dp[i][0]:长度为i但是不包含49的方案数
//dp[i][1]:长度为i且不含49但是以9开头的数字的方案数
//dp[i][2]:长度为i且包含49的方案数
void init()
{
	memset(dp, 0, sizeof(dp));
	dp[0][0] = 1;
	for (int i = 1; i <= 20; i++)
	{
		dp[i][0] = dp[i - 1][0] * 10 - dp[i - 1][1];//所有情况减去开头为4的情况
		dp[i][1] = dp[i - 1][0] * 1;//这个随便
		dp[i][2] = dp[i - 1][2] * 10 + dp[i - 1][1];//已经有的随便，有9的就加上4就行
	}
}

int cal(LL n)
{
	int k = 0;
	memset(c, 0, sizeof(c));
	while (n)
	{
		c[++k] = n % 10;
		n /= 10;
	}
	c[k + 1] = 0;
	return k;
}

void solve(int len, LL n)
{
	int flag = 0;                   //标记是否出现过49
	LL ans = 0;
	for (int i = len; i >= 1; i--)
	{
		ans += c[i] * dp[i - 1][2];       //为什么乘以c[i]因为可以有0~i-1个也就是i个
		if (flag)                    //如果之前出现过49那么直接乘以没有出现49的情况，因为初始时候已经乘以了有49的情况
			ans += c[i] * dp[i - 1][0];
		else if (c[i] > 4)           //这一位前面没有挨着49，但c[i]比4大，那么当这一位填4的时候，要加上dp[i-1][1]
			ans += dp[i - 1][1];
		if (c[i + 1] == 4 && c[i] == 9)
			flag = 1;
	}
	printf("%I64d\n", ans);
}

int main()
{
	int t;
	LL n;
	init();
	scanf("%d", &t);
	while (t--)
	{
		scanf("%I64d", &n);
		int len = cal(n + 1);
		solve(len, n);
	}
	return 0;
}





E	POJ 3252	Round Numbers

#include<cstdio>
#include<cstring>

int dp[50][50][50], digit[50], s, t;

//dfs间接枚举所有情况
int dfs(int pos, int zero, int one, int lead, int limit)//limit判断上一位数字是否达到上界,lead有没有1出现
{
	if (!pos)return zero >= one;
	if (!limit&&dp[pos][zero][one] != -1)
		return dp[pos][zero][one];
	int up = limit ? digit[pos] : 1, ans = 0;
	for (int i = 0; i <= up; i++)
		ans += dfs(pos - 1, lead ? zero + (i == 0) : 0, one + (i == 1), lead || i == 1, limit&&i == up);
	return  limit ? ans : dp[pos][zero][one] = ans;
}

int cal(int n)
{
	int len = 0;
	while (n)    digit[++len] = n % 2, n >>= 1;
	return dfs(len, 0, 0, 0, 1);
}

int main()
{
	memset(dp, -1, sizeof(dp));
	scanf("%d%d", &s, &t);
	printf("%d\n", cal(t) - cal(s - 1));
}





F	HDU 3709	Balanced Number

#include <iostream>
#include<cstdio>
#include<cstring>
using namespace std;

long long dp[30][30][3000];
int num[30];

long long dfs(int pos, int center, int sum, bool flag)
{
	if (pos == 0) return sum == 0;
	if (sum<0) return 0;
	if (!flag&&dp[pos][center][sum] != -1) return dp[pos][center][sum];
	long long ans = 0;
	int maxn = flag ? num[pos] : 9;
	for (int i = 0; i <= maxn; i++)
	{
		ans += dfs(pos - 1, center, sum + i*(pos - center), i == maxn&&flag);
	}
	if (!flag) dp[pos][center][sum] = ans;
	return ans;
}

long long cal(long long x)
{
	long long ans = 0;
	int pos = 0;
	while (x)
	{
		num[++pos] = x % 10;
		x /= 10;
	}
	for (int i = 1; i <= pos; i++)
		ans += dfs(pos, i, 0, 1);
	return ans - pos + 2;
}
int main()
{
	int t;
	long long n, m;
	memset(dp, -1, sizeof(dp));
	scanf("%d", &t);
	while (t--)
	{
		scanf("%I64d%I64d", &n, &m);
		printf("%I64d\n", cal(m) - cal(n - 1));
	}
	return 0;
}





G	HDU 3652 B - number

#include<iostream>
#include<cstdio>
#include<cstring>
#define mod 13
using namespace std;

int dp[20][15][4];
int num[20];

int dfs(int pos, int mo, int status, bool limit)
{
	if (!pos)  return status == 2 && mo == 0;
	if (!limit&&dp[pos][mo][status] != 0) return dp[pos][mo][status];

	int end = limit ? num[pos] : 9;
	int sum = 0;
	for (int i = 0; i <= end; i++)
	{
		int a = mo;
		int flag = status;
		if (flag == 0 && i == 1) flag = 1;
		if (flag == 1 && i == 3) flag = 2;
		if (flag == 1 && i != 1 && i != 3) flag = 0;
		sum += dfs(pos - 1, (a * 10 + i) % mod, flag, limit&&i == end);
	}
	return limit ? sum : dp[pos][mo][status] = sum;
}

int cal(int n)
{
	int pos = 1;
	memset(dp, 0, sizeof dp);
	while (n>0)
	{
		num[pos++] = n % 10;
		n /= 10;
	}
	return dfs(pos - 1, 0, 0, true);
}

int main()
{
	int n;
	while (~scanf("%d", &n))
	{
		printf("%d\n", cal(n));
	}
	return 0;
}





H	HDU 4734	F(x)

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;

int digit[20], dp[20][10000], t, a, b, ans, cas = 1;//dp[i][j]表示一共i位的数其中小于j的个数

int dfs(int pos, int st, bool limit)
{
	if (pos == 0)  return st >= 0;
	if (!limit&&dp[pos][st] != -1) return dp[pos][st];
	int end = limit ? digit[pos] : 9, ans = 0;
	for (int i = 0; i <= end; i++)
		ans += dfs(pos - 1, st - i*(1 << (pos - 1)), limit&&i == end);
	if (!limit)  dp[pos][st] = ans;
	return ans;
}

int f(int x)
{
	int sum = 0, cnt = 0;
	while (x)    sum += (x % 10)*(1 << (cnt++)), x /= 10;
	return sum;
}

int cal(int a, int b)
{
	int cnt = 0;
	while (b)    digit[++cnt] = b % 10, b /= 10;
	return dfs(cnt, f(a), 1);
}

int main()
{
	scanf("%d", &t), memset(dp, -1, sizeof(dp));
	while (t--)  scanf("%d%d", &a, &b), printf("Case #%d: %d\n", cas++, cal(a, b));
}





I	HDU 4507	吉哥系列故事――恨7不成妻

/*总状态转移思路
(1) ans.cnt += tmp.cnt
(2) ans.s += tmp.s + [ i*10^p ]*tmp.cnt
(3) ans.ss += tmp.ss + 2*(i*10^p)*tmp.s + [(i*10^p)^2]*tmp.cnt（平方和公式）
*/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstring>
using namespace std;
typedef long long ll;

const int N = 20;
const int mod = 1e9 + 7;

struct Node
{
	ll cnt, s, ss;                        //与 7 无关的数的个数,与 7 无关的数的和,与 7 无关的数的平方和
	Node() { cnt = -1; s = 0, ss = 0; } //默认的构造函数，初始化cnt顺便标记是否访问过
}dp[N + 2][10][10];


ll p[N + 2], dig[N + 2];                 //保存10的次方 PS：记得取模,保存数字的每一个数位上的数

void init()
{
	p[1] = 1;                           //因为我的数字的个位用dig[1]表示，所以我用p[1]记录10的0次方
	for (int i = 2; i < N; ++i) p[i] = (p[i - 1] * 10) % mod;
}

inline ll EX(ll x)                      //求平方
{
	x %= mod;
	return (x*x) % mod;
}

Node dfs(int len, int r1, int r2, bool up)
{
	if (len == 0)
	{
		Node tmp;
		tmp.cnt = (r1&&r2);             //数位和不是7的倍数且数字不是7的倍数,因为这里已经完成了一组排列，只要判断这里的就行了所以&&
		tmp.s = tmp.ss = 0;
		return tmp;
	}
	if (!up&&dp[len][r1][r2].cnt != -1)
		return dp[len][r1][r2];
	int n = up ? dig[len] : 9;
	Node ans; ans.cnt = 0;
	for (int i = 0; i <= n; ++i)
	{
		if (i == 7) continue;
		Node tmp = dfs(len - 1, (i + r1) % 7, (i + r2 * 10) % 7, up&&i == n);               //得到子状态
		ans.cnt = (ans.cnt + tmp.cnt) % mod;                                                //更新个数
		ans.s = (ans.s + (tmp.s + (i*p[len]) % mod*tmp.cnt%mod) % mod) % mod;               //更新数字
		ans.ss = (ans.ss + (tmp.ss + ((2LL * i*p[len] % mod)*tmp.s) % mod) % mod) % mod;    //式子太长分开写
		ans.ss = (ans.ss + (EX(i*p[len])*tmp.cnt) % mod) % mod;
	}
	if (!up) dp[len][r1][r2] = ans;
	return ans;
}

ll cal(ll x)
{
	int len = 0;
	while (x)
	{
		dig[++len] = x % 10;
		x /= 10;
	}
	return dfs(len, 0, 0, 1).ss;
}

int main()
{
	init();
	int T;
	scanf("%d", &T);
	while (T--)
	{
		ll l, r;
		scanf("%lld %lld", &l, &r);
		printf("%lld\n", ((cal(r) - cal(l - 1)) % mod + mod) % mod);
	}
	return 0;
}





J	SPOJ BALNUM		Balanced Numbers

#include <string.h>
#include <stdio.h>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;

LL dp[20][60000];
int bit[20];

bool check(int s)
{
	int num[10];
	for (int i = 0; i<10; i++)
	{
		num[i] = s % 3;
		s /= 3;
	}
	for (int i = 0; i<10; i++)
	{
		if (num[i] != 0)
		{
			if (i % 2 == 0 && num[i] == 2)return false;//偶数数字出现了奇数次，舍去
			if (i % 2 == 1 && num[i] == 1)return false;//奇数数字出现了偶数次，舍去
		}
	}
	return true;
}

int getnews(int x, int s)
{
	int num[10];
	for (int i = 0; i<10; i++)
	{
		num[i] = s % 3;
		s /= 3;
	}
	if (num[x] == 0)
		num[x] = 1;
	else
		num[x] = 3 - num[x];
	int news = 0;
	for (int i = 9; i >= 0; i--)
	{
		news *= 3;
		news += num[i];
	}
	return news;
}

LL dfs(int pos, int s, int flag, int z)
{
	if (pos == -1)	return check(s);
	if (!flag&&dp[pos][s] != -1)	return dp[pos][s];
	LL ans = 0;
	int end = flag ? bit[pos] : 9;
	for (int i = 0; i <= end; i++)
		ans += dfs(pos - 1, (z&&i == 0) ? 0 : getnews(i, s), flag&&i == end, z&&i == 0);

	if (!flag)dp[pos][s] = ans;
	return ans;
}

LL solve(LL n)
{
	int len = 0;
	while (n)
	{
		bit[len++] = n % 10;
		n /= 10;
	}
	return dfs(len - 1, 0, 1, 1);
}

int main()
{
	int T;
	memset(dp, -1, sizeof(dp));
	LL a, b;
	scanf("%d", &T);
	while (T--)
	{
		scanf("%lld%lld", &a, &b);
		printf("%lld\n", solve(b) - solve(a - 1));
	}
	return 0;
}

 

Egqawkq
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[kuangbin带你飞]专题二十二 区间DP
TelmaZzzz的博客
03-18 163
前言： 区间dp的题目一般有几个显然的模式，比如n的范围小于1000，且通过手动模拟发现没法贪心的题。 对于dp方程一般可以往 对区间内的贡献或者是对区间外的贡献这两个角度去考虑。（有时需要逆向思维去考虑） 对于dp状态的增加维，一般用于处理区间边界的状态。 做区间dp的题经常会用到前缀和来预处理状态之间转移的关系。 正文： A ZOJ-3537 题解： 这题可以划分为两个问题，一个是判断凸...
数位DP专题
Untersee-boot XXI
10-13 233
CF55D 这个题的核心要素是：某个数n被它的所有非零数位整除的同时，也是整除了所有非零数位的最小公倍数。所以在分析数位的同时需要照顾已经分析的所有非零数位的最小公倍数，和这些数位组成的这个数取余它的模。 所以dfs过程就有了三维数据：当前数位，余数，最小公倍数。然而余数和最小公倍数可能很大，在记忆化过程中较难实现，所以需要优化一下。可以发现1~9的最小公倍数为2520，如果一个数被2520整...
kuangbin专题十五数位dp总结
qq_34921856的博客
04-05 460
这里是一篇讲数位dp的文章 数位dp最重要的就是状态的建立！ A - Beautiful numbers 一道数位dp的好题。 不过理清思路后也挺好理解的。 题目要求求能被它所有位数整除的数的个数，换句话说就是能被它所有位数的lcm整数的数的个数，所以我们得维护一个lcm。又因为a%p=a%(k*p)%p。所以我们可以先将所有的数模上lcm(1,2,3…9),然后在最后再判断模lcm是...
Kuangbin带你飞 基础DP专题
killers_999的博客
04-23 284
bin神的DP专题真的有好多啊，整理一下做过的基础DP专题。 HDU1029Ignatius and the Princess IV http://acm.hdu.edu.cn/showproblem.php?pid=1029 题意 给出n，和n个数，找出至少出现(n+1)/2次的数字。 思路 至少出现(n+1)/2次，如果这个数存在那么排序后位于中间位置的一定是这个特殊的数。 H...
[kuangbin带你飞]专题二十 斜率DP
hhz6830975的博客
03-04 177
A 裸题，不写了 B&nbsp;&nbsp;&nbsp;&nbsp;~~hdu 2829 设dp[i][j]dp[i][j]dp[i][j]为前iii个点分jjj段的最小值 设val[i][j]val[i][j]val[i][j]为[i,j][i,j][i,j]的点为一段时的值，val[i]val[i]val[i]表示val[1][i]val[1][i]val[1][i] sum[i]s...
[kuangbin带你飞]专题十二 基础DP1
Do not mess it up
12-10 396
hdu 1024 Max Sum Plus Plus（DP缓存） Problem Description Now I think you have got an AC in Ignatius.L's "Max Sum" problem. To be a brave ACMer, we always challenge ourselves to more difficult prob
【kuangbin带你飞基础DP专题】 简要题解
lajiyuan的博客
08-30 1648
biubiubiu第一次尝试一天rush一套专题（由于这套简单一些），14个小时完成了，现在来补一下当时卡住的题或者比较有意思的题的题解。 按照AC人数写一下题解 HDU1029 http://acm.hdu.edu.cn/showproblem.php?pid=1029 这个题是一个非常经典的裁判官问题，有o(n)时间o(1)空间的解法，原理是根据如果这个数列中存在一个出现次数超...
KMP总结归纳 题型汇总(kuangbin带你飞专题16)
vaeloverforever的博客
08-27 685
前序：花了好几天才把带你飞系列的KMP专题(地址：https://vjudge.net/contest/246969#overview搞定，刷了很多题，发现KMP可以用来解决这几类问题： ①单个字符串匹配问题（s1在s2中匹配）：这个用strstr(const char* big, const char* small)函数也可以，这个函数返回small在big函数中首次出现的地址，没有出现就返回...
kuangbin带你飞 专题1-23 题单
HelloACM_ICPC的博客
01-27 2694
kuangbin大神，对于打过ACM比赛的ACMer，无人不知无人不晓。 在此，附上vjudge平台上一位大神整理的[kuangbin带你飞]专题目录链接。 [kuangbin带你飞专题目录1-23] : https://vjudge.net/article/187 专题一 简单搜索 POJ 1321 棋盘问题 POJ 2251 Dungeon Master POJ 3278 Catch That...
【kuangbin带你飞】专题十七AC自动机
cjlu zx的博客
11-25 201
文章目录hdu3247 - Resource Archiver思路代码 hdu3247 - Resource Archiver 思路 n的数据范围只有10，一开始想的是设置状态dp[i][j]dp[i][j]dp[i][j]表示第一维当前选择好字符串的状态为i，那么第一维最对为(1<<10)，此时AC自动机上的状态为j。转移方程即为dp[i∣vis[p]][p]=min(dp[i][j]+1)dp[i|vis[p]][p]=min(dp[i][j]+1)dp[i∣vis[p]][p]=min(d
解题报告：【kuangbin带你飞】专题九 连通图
繁凡さん的博客
09-14 2954
目录A、POJ 1236 Network of Schools（有向图缩点）B、UVA 315 Network（找割点）C、UVA 796 Critical Links（桥）D、POJ 3694 NetworkE、POJ 3177 Redundant PathsF、HDU 4612 Warm upG、HDU 4635 Strongly connected（最多可加边数使得仍然非强连通）H、HDU 4685 Prince and PrincessI、HDU 4738 Caocao's Bridges A、PO
To Do List：kuangbin带你飞
qq_37087993的博客
10-16 306
两个多星期没刷题了。。。 确实有很多东西阻碍前进的步伐 但寻思着既然喜欢一个东西，就尽量不要被现实的一些琐事影响吧 放一个别人整理的链接： https://cn.vjudge.net/article/187 目标：70%吧 时限：这个学期 做完了标粗体吧hhh（简陋） 专题一 简单搜索 POJ 1321 棋盘问题 POJ 2251 Dungeon Master POJ 3278 Catch Tha...
【 题集 】 【kuangbin带你飞】专题十二 基础DP1
Joursion
02-28 1236
B - Ignatius and the Princess IV Time Limit:1000MS     Memory Limit:32767KB     64bit IO Format:%I64d & %I64 Description "OK, you are not too bad, em... But you can never pass the next te
[kuangbin带你飞]专题十二 基础DP 题解
一叶之修的博客
04-27 355
专题十二 基础DP HDU 1024Max Sum Plus Plus HDU 1029Ignatius and the Princess IV HDU 1069Monkey and Banana HDU 1074Doing Homework HDU 1087Super Jumping! Jumping! Jumping! HDU 1114Piggy-Bank HDU 1...
【HDU 5787】K-wolf Number（数位DP）
ACMer'
08-03 1769
【HDU 5787】K-wolf Number（数位DP）K-wolf NumberTime Limit: 6000/3000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)Total Submission(s): 384    Accepted Submission(s): 136Problem Description
hdu1024 Max Sum Plus Plus
Egqawkq的博客
09-30 210
题意： 给定一个数组，求其分成m个不相交子段和最大值。 思路： dp[i][j]表示数组前j个数分成i段的话的最大值，状态的转移如下：dp[i][j]=max(dp[i][j-1],dp[i-1][k])+a[j] ，考虑到这里的数组最大为1e7，所以只是一般的写二维数组肯定爆的，于是采用滚动数组，就是每一个j记录前一次状态的最大值，具体的过程看了代码就懂了。 代码：
Rodrigues公式推导
Egqawkq的博客
02-06 571
最近在看立体视觉的相关内容，在完成了双目相机的标定之后直接面临的一个问题就是关于图像校正（行对准），由于标定出来的R是按照om矩阵的形式出现的，所以需要预先使用罗德里格斯公式计算，于是就推导了一下公式。 ...
Codeforces Round #436 (Div. 2)C. Bus codeforces 864C. Bus
Egqawkq的博客
09-26 496
C. Bus time limit per test  2 seconds memory limit per test  256 megabytes input  standard input output  standard output A bus moves along the coordinate line Ox from th
LeetCode87. Scramble String(递推、剪枝)(每日一题——2019.3.31)
Egqawkq的博客
03-31 213
题意：给一二叉树，对于非叶子节点可以交换左右孩子结点，从而形成了新的树，继而每个结点代表的字符串打乱顺序，问你给你两个字符串s1与s2，问s2是否可以由s1做上述操作得到。 Below is one possible representation ofs1="great": great / \ gr eat / \ / \ g r e ...
ACM模板：字符串处理与数学算法详解
"ACM常用算法模板文档由kuangbin提供，收录了丰富的字符串处理、数学及相关数论算法。该模板主要分为两个部分：字符串处理和数学。 在字符串处理章节，核心算法包括： 1. KMP (Knuth-Morris-Pratt)算法，用于在文本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值