SDNU_ACM_ICPC_2022_Winter_Practice_1th [个人赛]

已于 2022-01-19 00:27:23 修改
阅读量217 收藏
点赞数 1
文章标签： 动态规划 算法
于 2022-01-17 21:26:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eyuhaobanga/article/details/122547963
版权

A

Multiple of 2019 - AtCoder abc164_d - Virtual Judge

比赛时第一眼认为是01背包题，然后直接背上板子，dp我还是太辣鸡，什么动态转移，动态方程都不会，要么能分析出咋变化的，要么变变初始状态凑凑数，要么直接放弃。

思路：通常的01背包，跑一遍对于这个题目来说就是从1到1.....n中所有的方案数，因此其中并没有包括2到2....n ......n到n的方案数，因此我考虑的是每一次都把自己当作另一个背包，多路并进，即每次dp[0]都+1，具体看下面的拙图QAQ

 AC代码：

#include <iostream>
#include <queue>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <map>
#include <vector>
#include <set>
#include <stack>
#include <list>
#include <numeric>
#include <iomanip>
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = 998244353;
long long a[3030];
long long b[3030];
void solve() {
	int n, s;
	cin >> n >> s;
	for (int i = 1; i <= n; i++) {
		cin >> a[i];
	}
	long long ans = 0;
	b[0] = 1;
	for (int i = 1; i <= n; i++) {
		
		for (int j = s; j - a[i] >= 0; j--) {
			b[j] = (b[j] + b[j - a[i]]) % mod;
		}
		
		ans = (ans + b[s]) % mod;
		b[0]++;
	}
	cout << ans % mod << endl;
	return;
}
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	solve();
	return 0;
}

B

Dividing Chocolate - AtCoder abc159_e - Virtual Judge

由题目数据可以看出，对于每一行来说我们可以直接暴力采用二进制枚举所有可能切割的情况，这里为什么会想到二进制呢，因为可以用二进制来表示每一行到底切还是不切，比如有四行，那么就用两位就可以表示所有情况：00，01，10，11四种切法，输入的时候顺便记录一下每一行的前缀和，然后再判断每一列的情况，其中切行的时候最多切h-1下

AC代码：

1.

#include <iostream>
#include <queue>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <map>
#include <vector>
#include <set>
#include <stack>
#include <list>
#include <numeric>
#include <iomanip>
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = 998244353;
int h, w, k, pre[20][1010], flag, ans = INF;
char ch;
void solve() {
	scanf("%d %d %d", &h, &w, &k);
	for (int i = 1; i <= h; i++) {
		for (int j = 1; j <= w; j++) {
			scanf(" %c", &ch);
			pre[i][j] = pre[i][j - 1] + ch - '0';
		}
	}
	for (int state = 0; state < (1 << h - 1); state++) {
		int last = 0, sum = 0, cnt = 0, flag = 1;
		for (int j = 1; j <= w; j++) {
			for (int i = 1; i <= h; i++) {
				sum = sum + pre[i][j] - pre[i][last];
				if (sum > k) {
					if (j - last == 1) {
						flag = 0;
						break;
					}
					i = 0, sum = 0, last = j - 1;
					cnt++;
				}
				if (i == h || state & (1 << (i - 1))) {
					sum = 0;
				}
			}
			if (!flag) {
				break;
			}
		}
		if (flag) {
			int m = 0;
			for (int l = 0; l < h - 1; l++) {
				if ((state >> l) & 1) {
					m++;
				}
			}
			ans = min(ans, m + cnt);
		}
	}
	printf("%d\n", ans);
	return;
}
int main() {
	//ios::sync_with_stdio(0);
	//cin.tie(0);
	solve();
	return 0;
}
/*

*/

2.(个人感觉第二个更容易理解一点)

对于每一行来说我们可以直接暴力采用二进制枚举所有可能切割的情况，这里为什么会想到二进制呢，因为可以用二进制来表示每一行到底切还是不切，比如有四行，那么就用两位就可以表示所有情况：00，01，10，11四种切法，所以就可以通过位运算&1来判断当前这种情况下这一行切没切，从而实现判断这一列符合条件的时候也判断了行有没有切到位，如果切到位了，这一列肯定不会超，如果没切到位，那肯定就是行没有切到位，这时候再去切某一列就没有任何意义了，如果一行里超了的话那只能竖着切一刀，然后再判断一下如果竖着切了一刀后满不满足题意，如果还不行那就是行切少了，直接再判断下一种切行的情况而不更新答案

#include<bits/stdc++.h>
#define fi first
#define se second
#define mp make_pair
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
const double eps = 1e-8;
const int NINF = 0xc0c0c0c0;
const int INF  = 0x3f3f3f3f;
const ll  mod  = 1e9 + 7;
const ll  N = 1e3 + 5;

int n,m,k,z;
string s[15];
int c[15];

bool f(int j){//返回true代表要切一刀竖着的，因为至少有一块已经超过k了
	int id=0;
	for(int i=0;i<n;i++){
		c[id]+=s[i][j]=='1';
		if(c[id]>k) return true;//超过k了 要切哦
		if(z>>i & 1) id++;
	}
	return false;//不用切 依旧满足
}

int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	cin>>n>>m>>k;
	for(int i=0;i<n;i++) cin>>s[i];
	int ans=0x3f3f3f3f;
	for(z=0;z<1<<n-1;z++){//长度为n那么可以切n-1刀，枚举0~2^(n-1)-1的状态，1代表切，0代表不切。
		memset(c,0,sizeof(c));
		bool ok=false;
		int cnt=__builtin_popcount(z);//横着切了多少刀
		for(int j=0;j<m;j++){//现在横着切完要贪心求竖着了
			if(f(j)){//要竖着切一刀
				cnt++;//竖着切了一刀
				memset(c,0,sizeof(c));//那么切完之后竖着的每一块又都是0了
				ok=f(j);//如果竖着切了一刀，哪怕是一列还是不行，那说明横着切少了，无论如何都不满足
			}
		}
		if(!ok) ans=min(ans,cnt);//满足条件的时候记录最小值
	}
	cout<<ans;
	return 0;
}

C

Maximum Volume - AtCoder abc159_c - Virtual Judge

C题打眼一看求最大体积，然后长宽高的和等于L，根据不等式就能知道当且仅当a=b=c的时候a*b*c是最大的

AC代码：

#include <iostream>
#include <queue>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <map>
#include <vector>
#include <set>
#include <stack>
#include <list>
#include <numeric>
#include <iomanip>
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = 998244353;
const double eps = 1e-6;
void solve() {
	double l;
	cin >> l;
	double s = l / 3.0;
	cout << fixed << setprecision(11) <<s * s * s << endl;
	return;
}
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	solve();
	return 0;
}

D

String Palindrome - AtCoder abc159_b - Virtual Judge

判断回文，要判断三个条件就可以了，N是输入字符串总长度，第一个条件是给的字符串就得是回文的，第二个条件是从第一个字符到第（N-1）/2个字符之间的字符串是回文的，第三个条件是从第（N+3）/2个字符到第N个字符之间的字符串是回文的，然后就是输出了

AC代码：

#include <iostream>
#include <queue>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <map>
#include <vector>
#include <set>
#include <stack>
#include <list>
#include <numeric>
#include <iomanip>
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = 998244353;
const double eps = 1e-6;
void solve() {
	string s;
	cin >> s;
	int len = s.length();
	int x = (len - 1) / 2, y = (len + 3) / 2;//x=3,y=5,len=7
	bool ok = true;
	for (int i = 0; i < len; i++) {
		if (s[i] != s[len - i - 1]) {
			ok = false;
			break;
		}
	}
	for (int i = 0; i < x; i++) {
		if (s[i] != s[x - i - 1]) {
			ok = false;
			break;
		}
	}
	for (int i = len - 1; i >= y; i--) {
		if (s[i] != s[y + len - i - 2]) {
			ok = false;
			break;
		}
	}
	if (ok) {
		cout << "Yes" << endl;
	}
	else {
		cout << "No" << endl;
	}
	return;
}
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	solve();
	return 0;
}

E

Banned K - AtCoder abc159_d - Virtual Judge

这个题就是组合题，给一个序列，然后用map记录一下每个数的出现的次数，求这些数一共能形成多少对两个数相等的组合，也就是一个数必须出现了两次以上才能形成至少一种组合，否则形不成，我先假设没把第k个数拿出去，就是x*（x-1）/2，算完了以后，我再算把第k个数拿出去的情况，这样我只需要把算的总和减去x*（x-1）/2然后再加上（x-1）*（x-2）/2，就是答案

AC代码：

#include <iostream>
#include <queue>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <map>
#include <vector>
#include <set>
#include <stack>
#include <list>
#include <numeric>
#include <iomanip>
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int mod = 998244353;
const double eps = 1e-6;
long long n;
long long a[200010];
map<long long, long long> b;
void solve() {
	cin >> n;
	for (ll i = 1; i <= n; i++) {
		cin >> a[i];
		b[a[i]]++;
	}
	ll ans = 0;
	map<ll, ll>::iterator it;
	for (it = b.begin(); it != b.end(); it++) {
		ll x = it->second;
		if (x >= 2) {
			ans += x * (x - 1) / 2;
		}
	}
	for (ll i = 1; i <= n; i++) {
		if (b[a[i]] >= 2) {
			
			cout << ans - b[a[i]] * (b[a[i]] - 1) / 2 + (b[a[i]] - 1) * (b[a[i]] - 2) / 2 << endl;
		}
		else {
			cout << ans << endl;
		}
	}
	return;
}
signed main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	solve();
	return 0;
}

F

Multiple of 2019 - AtCoder abc164_d - Virtual Judge

这就是大数取模，只要同一个模数大于1，说明一定至少存在两个数，假设x，y，x%2019=y%2019，x = a*2019+b，y = c*2019+b，直接假设数字表示一下，x=20192020，y=2020->x=2019*10001+1，y=2019*1+1，因此能够得出（x-y）的绝对值一定是2019的倍数，因此说明只要一个模数能取出来的次数大于1，那么至少能得到一个被2019整除的数

AC代码：

#include <iostream>
#include <queue>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <map>
#include <vector>
#include <set>
#include <stack>
#include <list>
#include <numeric>
#include <iomanip>
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = 998244353;
const double eps = 1e-6;
long long f[2022];
char s[200010];
void solve() {
	scanf("%s", s + 1);
	long long len = strlen(s + 1);
	f[0] = 1;
	long long sign = 0;
	long long a = 1;
	long long ans = 0;
	for (long long i = len; i >= 1; i--) {
		sign = (sign + (s[i] - '0') * a) % 2019;
		a = a * 10 % 2019;
		ans += f[sign];
		f[sign]++;
	}
	cout << ans << endl;
	return;
}
int main() {
	//ios::sync_with_stdio(0);
	//cin.tie(0);
	//
	solve();
	return 0;
}

G

A Simple Problem with Integers - POJ 3468 - Virtual Judge

线段树or树状数组模板题，菜菜的我只能算是会树状数组，线段树emmm

AC代码：

#include <iostream>
#include <queue>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <map>
#include <vector>
#include <set>
#include <stack>
#include <list>
#include <numeric>
#include <iomanip>
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = 998244353;
const double eps = 1e-6;
long long tree1[100010],tree2[100010];
int a[100010];
int n,q;
int lowbit(int x) {
	return x & -x;
}
void add(int p,int x) {
	long long v = p * x;
	for (int i = p; i <= n; i += lowbit(i)) {
		tree1[i] += x;
		tree2[i] += v;
	}
	return;
}
long long get(int x) {
	long long ans = 0;
	for (int i = x; i > 0; i -= lowbit(i)) {
		ans += (x + 1) * tree1[i] - tree2[i];
	}
	return ans;
}
void solve() {
	cin >> n >> q;
	for (int i = 1; i <= n; i++) {
		cin >> a[i];
	}
	vector<long long> ve(n + 10);
	adjacent_difference(a + 1, a + 1 + n, ve.begin() + 1);
	for (int i = 1; i <= n; i++) {
		tree1[i] += ve[i];
		tree2[i] += 1ll * ve[i] * i;
		long long j = i + lowbit(i);
		if (j <= n) {
			tree1[j] += tree1[i];
			tree2[j] += tree2[i];
		}
	}
	while (q--) {
		char op;
		cin >> op;
		if (op == 'C') {
			int x, y, z;
			cin >> x >> y >> z;
			add(x, z);
			add(y + 1, -z);
		}
		else {
			int x, y;
			cin >> x >> y;
			cout << get(y) - get(x - 1) << endl;
		}
	}
	return;
}
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	solve();
	return 0;
}

H

Networking - POJ 1287 - Virtual Judge

最小生成树模板题，遇到最小生成树，率先想到Kruscal，碰到稠密图的prim那就emmmm

AC代码：

#include <iostream>
#include <queue>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <map>
#include <vector>
#include <set>
#include <stack>
#include <list>
#include <numeric>
#include <iomanip>
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = 998244353;
const double eps = 1e-6;
int n, e;
struct node {
	int from, to, cost;
}poi[10000];
int fa[110];
bool cmp(node a, node b) {
	return a.cost < b.cost;
}
int get(int x) {
	return x == fa[x] ? x : fa[x] = get(fa[x]);
}
void solve() {
	long long ans = 0;
	for (int i = 1; i <= e; i++) {
		cin >> poi[i].from >> poi[i].to >> poi[i].cost;
	}
	for (int i = 1; i <= n; i++) {
		fa[i] = i;
	}
	sort(poi + 1, poi + 1 + e, cmp);
	for (int i = 1; i <= e; i++) {
		int x = get(poi[i].from);
		int y = get(poi[i].to);
		if (x != y) {
			fa[x] = y;
			ans += poi[i].cost;
		}
	}
	cout << ans << endl;
	return;
}
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	while (cin >> n) {
		if (n == 0) {
			break;
		}
		cin >> e;
		solve();
	}
	return 0;
}

J

Base K - AtCoder abc220_b - Virtual Judge

N进制转十进制然后再相乘

AC代码：

#include <iostream>
#include <queue>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <map>
#include <vector>
#include <set>
#include <stack>
#include <list>
#include <numeric>
#include <iomanip>
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = 998244353;
const double eps = 1e-6;
void solve() {
	long long a, b, k;
	cin >> k >> a >> b;
	long long suma = 0, sumb = 0;
	long long x = 1, y = 1;
	while (a) {
		suma += (a % 10) * x;
		x *= k;
		a /= 10;
	}
	while (b) {
		sumb += (b % 10) * y;
		y *= k;
		b /= 10;
	}
	cout << suma * sumb << endl;
	return;
}
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	solve();
	return 0;
}

K

Long Sequence - AtCoder abc220_c - Virtual Judge

求给定数列循环多少下的和数超过x，判断+跑循环就好了

AC代码：

#include <iostream>
#include <queue>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <map>
#include <vector>
#include <set>
#include <stack>
#include <list>
#include <numeric>
#include <iomanip>
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = 998244353;
const double eps = 1e-6;
int a[100010];

void solve() {
	long long n, x;
	long long sum = 0;
	cin >> n;
	for (int i = 1; i <= n; i++) {
		cin >> a[i];
		sum += a[i];
	}
	cin >> x;
	bool ok = true;
	long long ans;
	while (ok) {
		ans = x / sum * n;
		x %= sum;
		
		for (int i = 1; i <= n; i++) {
			x -= a[i];
			if (x < 0) {
				ok = false;
				ans += i;
				break;
			}
		}
	}
	cout << ans << endl;
	return;
}
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	solve();
	return 0;
}

L

迷宫问题 - POJ 3984 - Virtual Judge

记忆化搜索bfs，单纯的bfs这个题简单，难在他还要你还原怎么走的，该题的起点就是左上角，终点就是右下角，我们只需要在原图的基础上再另外建立一张图来记录当前这个点是从哪个点走过来的，然后跑一遍bfs，但这样还只能倒着输出整条路径，所以可以用栈先进后出的特性，保存一遍路径，再挨个弹栈输出就行了

AC代码：

#include <iostream>
#include <queue>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <map>
#include <vector>
#include <set>
#include <stack>
#include <list>
#include <numeric>
#include <iomanip>
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = 998244353;
const double eps = 1e-6;
int dir[4][2] = { {1,0},{0,1},{-1,0},{0,-1} };
int mp[10][10];
struct node {
	int x, y;
}poi[10][10];
int cnt;
bool vis[10][10];
void solve() {
	for (int i = 1; i <= 5; i++) {
		for (int j = 1; j <= 5; j++) {
			cin >> mp[i][j];
		}
	}
	cnt = 0;
	vis[1][1] = true;
	queue<node> q;
	q.push(node{ 1,1 });
	while (!q.empty()) {
		struct node now = q.front();
		q.pop();
		if (now.x == 5 && now.y == 5) {
			break;
		}
		for (int i = 0; i < 4; i++) {
			node next;
			next.x = now.x + dir[i][0];
			next.y = now.y + dir[i][1];
			if (!vis[next.x][next.y] && next.x > 0 && next.x <= 5 && next.y > 0 && next.y <= 5 && mp[next.x][next.y] != 1) {
				q.push(next);
				vis[next.x][next.y] = true;
				poi[next.x][next.y] = now;
			}
		}
	}
	stack<node> st;
	struct node pre = { 5, 5 };
	while (1) {
		st.push(pre);
		if (pre.x == 1 && pre.y == 1) {
			break;
		}
		pre = poi[pre.x][pre.y];
	}
	while (!st.empty()) {
		
		cout << "(" << (st.top().x -= 1) << ", " << (st.top().y -= 1) << ")" << endl;
		st.pop();
	}
	return;
}
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	solve();
	return 0;
}

eyuhaobanga
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SDNU_ACM_ICPC_2019_Winter_Practice_4th 题解
qq_41431762的博客
02-01 1154
A - Frog Jumping A frog is currently at the point 00 on a coordinate axis OxOx. It jumps by the following algorithm: the first jump is aa units to the right, the second jump is bbunits to the left, t...
Objective-C_OAuth_SDK:i.sdnu.edu.cn的Objective-C SDK
06-08
1. **源代码**：通常以`.m`和`.h`文件形式存在，实现了OAuth相关的类和方法，例如OAuthToken管理、签名生成、请求处理等。 2. **示例项目**：可能包含一个Xcode工程，展示了如何在实际应用中使用SDK进行OAuth认证，...
SDNU_ACM_ICPC_2022_Winter_Practice_4th [个人赛]
eyuhaobanga的博客
02-14 313
A A Funny Game - POJ 2484 - Virtual Judge A博弈 AC代码： #include <iostream> using namespace std; int main() { int n; while (cin >> n) { if (n == 0) { break; } if (n <= 2) { cout << "Alice" << endl; } else { .
SDNU_ACM_ICPC_2022_Winter_Practice_5th [个人赛]
eyuhaobanga的博客
02-16 266
A Brackets - POJ 2955 - Virtual Judge 区间DP AC代码： /* Tips: 1.int? long long? 2.don't submit wrong answer 3.figure out logic first, then start writing please 4.know about the range 5.check if you have to input t or not 6.modulo of neg.
SDNU_ACM_ICPC_2022_Winter_Practice_6th [个人赛]
qq_62615329的博客
02-19 527
A A - Booby Prize 题意：给出n个不同的整数，问第二大的整数是第几个整数。 思路：结构体排序 #include <stdio.h> #include <cstdio> #include <cmath> #include <algorithm> #include <iostream> #include <map> #include <stack> #include <string> #in
SDNU_ACM_ICPC_2022_Winter_Practice_2th [个人赛]
qq_62615329的博客
01-20 2983
C Yet Another Array Restoration 给定两个元素x和y，及项数n，求最大元素最小的等差数列。思路：让公差d尽量的小，然后从x和y中较大的一个不断-d枚举，若项数不到n，继续从较大元素不断+d枚举。 #include <bits/stdc++.h> using namespace std; typedef long long ll; const int maxx = 1e6 + 10; int t,n,x,y; int main() { cin>
SDNU_ACM_ICPC_2021_Winter_Practice_5th [个人赛]
Suryxin's blogs
01-28 173
SDNU_ACM_ICPC_2021_Winter_Practice_5th [个人赛] 传送门 I - Stone 题意： 唐和江进行游戏，规则是，对于给定的n和k，唐先手，在黑板上写出[1，k]的数，再加下来每次写的数必须>=上次的数加1，<=上次的数加k，谁写出的先超过n即输 思路： 巴什博弈的变形。巴什博弈是n到0输，现在是1到n输，我们可以把它看成n - 1到0的巴什博弈即可，当（n - 1）% k == 0时先手输，即江赢，否则唐赢 #include<bits/stdc++.h
SDNU_ACM_ICPC_2021_Winter_Practice_9th [个人赛]（部分）
qq_33969563的博客
03-02 184
SDNU_ACM_ICPC_2021_Winter_Practice_9th [个人赛]（部分） G - 小约翰的游戏John 黑暗爆炸 - 1022 这个叫反尼姆游戏，因为取到最后一颗石头的人输 博弈论
SDNU_ACM_ICPC_2021_Winter_Practice_4th [个人赛]
Suryxin's blogs
01-28 117
SDNU_ACM_ICPC_2021_Winter_Practice_4th [个人赛] 传送门 D - Odd Divisor 题意： 给你一个n，问你n是否至少有一个奇数因子（这里题意没说清，没说是不是只有一个还是可以有多个！AC以后才发现是不止一个 思路： 如果这个数没有奇数因子，那它肯定是2^k 1.所以我就开始用循环除2，看看最后是不是奇数，1除外，因为2的k次方除到最后就剩下1，所以得特判。但是这个做法感觉还是不够妙 再两个妙的做法： 2.因为2^k是指数函数，而与指数函数互为反函数的对数函数，
SDNU_ACM_ICPC_2020_Winter_Practice_4th [Reproduced]
qq_43721152的博客
02-05 140
文章目录B - So Easy!C - Reading comprehension HDU - 4990H - TriangleI - Birthday ParadoxK - Reverse a SubstringL - Game with Telephone NumbersM - Alarm Clocks Everywhere B - So Easy! 思路：共轭矩阵的构造 C - Readin...
SDNU_OJ.rar_sdnu_sdnu oj_sdnu oj 1090_sdnu1020_sdnuoj1002代码
09-24
1. **基本算法和数据结构**：ACM基本题目通常涵盖基础的算法和数据结构，例如排序（快速排序、归并排序、冒泡排序等）、搜索（二分查找、广度优先搜索、深度优先搜索等）、图论（最短路径、最小生成树等）以及动态...
SDNU 面向对象程序设计及C++ MFC 期中作业 约瑟夫环.zip
05-23
SDNU 面向对象程序设计及C++ MFC 期中作业 约瑟夫环 免费的部分作业：https://blog.csdn.net/The___Flash/article/details/103564115 如有问题请私聊博主哦，博主看到的话一定会尽快回复的！ PS：没有 C 币的小伙伴...
算法练习题13——除自身以外数组的乘积（动态规划）
hello77的blogggg 祝你得偿所愿
09-04 900
给你一个整数数组nums，返回 数组answer，其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。
【大数据分析与挖掘算法】matlab实现——Apriori关联规则算法
Robbi_的博客
09-04 682
四、实验结果。
C语言：刷题笔记
weixin_45930573的博客
09-04 413
c语言刷题记录
树状数组记录
最新发布
volcan的博客
09-06 625
树状数组（Fenwick Tree）是一种用于维护数组前缀和的数据结构，支持高效的单点更新和区间查询操作。它的查询和更新时间复杂度为Ologn，适用于需要频繁更新和查询的场景。
力扣刷题--1534. 统计好三元组【简单】
m0_75266675的博客
09-04 380
力扣刷题--1534. 统计好三元组【简单】
【算法】单词出现次数和位置统计
Hanbuhuic的博客
09-04 387
编写一个程序，用于统计一个给定单词在一段文本中出现的次数以及第一次出现的位置。如果单词在文本中出现，则输出出现次数和第一次出现的位置（位置从0开始计算）。如果单词没有出现，则输出-1。
手机信令数据怎么获得_运用手机信令数据研究大都市区空间结构 ——以南昌大都市区为例...
06-11
获取手机信令数据有多种途径，其中一种常见的方式是通过与移动运营商合作，利用其网络设备获取数据。具体来说，我们可以通过与运营商签订数据共享协议，获取其网络中的信令数据，包括手机的位置、通话记录、短信记录等信息。此外，我们也可以通过自建基站或者使用第三方的基站设备来获取信令数据。 如果你想利用手机信令数据研究大都市区空间结构，可以先收集一定的数据量，然后运用数据挖掘和统计分析方法进行分析。具体地，可以使用聚类分析、空间分析等方法来研究城市中不同区域的人口密度、交通状况、商业活动等情况，以及它们之间的关系。最后，通过分析数据得出结论，并提出相应的政策建议，帮助城市规划和管理部门优化城市空间结构。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值