代码源每日一题Div2

最新推荐文章于 2024-06-09 20:18:37 发布
最新推荐文章于 2024-06-09 20:18:37 发布
阅读量631 收藏 1
点赞数
分类专栏： 东北大学秦皇岛分校acm训练营作业 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sign_river/article/details/129599670
版权

 一个小整数

 思路:

开始思路是找规律,for遍历每个数,然后插空什么的,结果问题就是有很多情况考虑不到.最后换了dfs解法,

首先判断数量最多的数的数量和其他数数量总和的关系 

1.如果数量最多的数的数量大于其他数数量总和+1,那么一个隔一个插空都插不了,空不够,直接判失败

2.如果数量最多的数的数量等于其他数数量总和+1,这个时候就只能把最大的这个数推进用于排序的数组

3.如果数量最多的数的数量小于其他数数量总和+1,这个时候就是选合适的最小的数的时候了

最后把用于排序的数组遍历输出一下,结束

当然中间要处理一些特殊情况,比如如果只有一个零,那就在开始直接判断然后输出,不用进入dfs了

#define _CRT_SECURE_NO_WARNINGS
#include<bits/stdc++.h>
int shuliang[10];
using namespace std;
int dfs(vector<int>& a) {
	int qiyv = 0, maxx = 0, maxshu = -1;
	for (int e = 0; e < 10; e++) {
		if (shuliang[e] > maxx) {
			maxx = shuliang[e];
			maxshu = e;
		}
		qiyv += shuliang[e];
	}
	if (qiyv == 0) {
		return 1;
	}
	qiyv -= maxx;
	if (qiyv + 1 < maxx) {
		return 0;
	}
	if (qiyv + 1 == maxx) {
		if (maxshu == 0 && a.size() == 0) {
			return 0;
		}
		else {
			a.push_back(maxshu);
			shuliang[maxshu]--;
		}
	}
	else {
		int k1 = 0;
		int pan1 = 0;
		if (a.size() == 0) {
			k1 = 1;
			pan1 = -1;
		}
		else {
			k1 = 0;
			pan1 = a.back();
		}
		for (int e = k1; e < 10; e++) {
			if (shuliang[e] > 0 && e !=pan1) {
				a.push_back(e);
				shuliang[e]--;
				break;
			}
		}
	}
	dfs(a);
}
int main() {
	int x = 1;
	for (int e = 0; e < 10; e++) {
		scanf("%d", &shuliang[e]);
		if (e != 0 && shuliang[e] != 0) {
			x = 0;
		}
	}
	if (x&&shuliang[0]==1) {
		printf("%d", 0);
		return 0;
	}
	vector<int>a;
	if (dfs(a)) {
		for (auto i : a) {
			cout << i;
		}
	}
	else {
		cout << -1;
	}
}

 特殊正方形

 思路:

开始string一个字符串为n个+,然后找规律,每一层把除了最外层里面的+变成.,之后在把除了最外层.里面的.变成+,每变一次输出一次同时用stack接收,之后把stack中的数据再输出出来就是完整的正方形

#include <bits/stdc++.h>
using namespace std;
stack<string>h;
int main()
{
	int a;
	cin >> a;	
	string m;
	int panduan = 0;
	int jishu = 0;
	for (int e = 0; e < a; e++) {
		m += "+";
	}
	for (int ii = 0; ii < a / 2; ii++) {
		if (panduan == 0) {
			for (int e = jishu; e < (a - jishu); e++) {
				m[e] = '+';
			}
			panduan = 1;
		}
		else {
			for (int e = jishu; e < (a - jishu); e++) {
				m[e] = '.';
			}
			panduan = 0;
		}
		h.push(m);
		for (int e = 0; e < m.size(); e++) {
			cout << m[e];
		}
		cout << endl;
		jishu++;
	}
	if (a % 2 != 0) {
		if (panduan == 0) {
			for (int e = jishu; e < (a - jishu); e++) {
				m[e] = '+';
			}
			panduan = 1;
		}
		else {
			for (int e = jishu; e < (a - jishu); e++) {
				m[e] = '.';
			}
			panduan = 0;
		}
		for (int e = 0; e < m.size(); e++) {
			cout << m[e];
		}
		cout << endl;
	}
	while (!h.empty()) {
		cout << h.top() << endl;
		h.pop();
	}
}

 走楼梯

 思路:

用动态分布解决,建立数组dp[i][j],j分为三个,计算上两节的数量,分为dp[i+1][0],和dp[i+2][1],dp[i+2][2],进行计算.

#include<bits/stdc++.h>
#include<Windows.h>
using namespace std;
int dp[55][3];
int x[2] = { 1,2 };
int main() {
	int aa;
	cin >> aa;
	dp[0][0] = 1;
	for (int e = 1; e <=aa; e++) {//最外层
		dp[e][0] = dp[e][0]+dp[e - 1][0] + dp[e - 1][1] + dp[e - 1][2];
		if (e - 2 >= 0) {
		dp[e][1] = dp[e][1] + dp[e - 2][0];
		dp[e][2] = dp[e][2] + dp[e - 2][1];
		}
	}
	/*for (int e = 0; e <= aa; e++) {
		for (int i = 0; i < 3; i++) {
			cout << dp[e][i];
		}
		cout << endl;
	}*/
	cout << dp[aa][0] + dp[aa][1] + dp[aa][2];
}

 走路

 思路:

之前先用dfs写的,逻辑到没啥问题,但是超时,全部超时,麻了,改成动态规划,开一个dp[i][j]二维数组,i表示走的次数,j的大小跟m+1一样大,目的就是统计看哪个点被走了,思路就是遍历每一个j如果是1,就加上ai或bi,一步一步下去,最后输出dp[n],结束,后面优化了下空间复杂度.

dfs算法

#include<bits/stdc++.h>
using namespace std;
int n, m;
int hhh[105][2];
int panduan[105][3] = {0};
vector<int>mm;
void dfs(int x,int y) {
	if (y == n+1) {
		if (m>=x) {
			mm[x] = 1;
			//cout << "JJJ" << endl;
		}
		return;
	}
	if (panduan[y][0] == 0) {
		panduan[y][0] = 1;
		dfs(x + hhh[y][0], y+1);
		//cout << "hhh";
	}
	if (panduan[y][1] == 0) {
		panduan[y][1] = 1;
		dfs(x + hhh[y][1], y+1);
	}
	panduan[y][1] = 0;
	panduan[y][0] = 0;
	//cout << "kkk";
	return;
}
int main() {
	cin >> n >> m;
	for (int e = 0; e <= m; e++) {
		mm.push_back(0);
	}
	for (int e = 1; e <= n; e++) {
		cin >> hhh[e][0] >> hhh[e][1];
	}
	dfs(0,1);
	for (auto i : mm) {
		cout << i;
	}
}

动态规划

#include<bits/stdc++.h>
using namespace std;
int shujv[105][2];
int dp[105][100005];
int main() {
	int n, m;
	cin >> n >> m;
	for (int e = 1; e <= n; e++) {
		cin >> shujv[e][0] >> shujv[e][1];
	}
	dp[0][0] = 1;
	for (int e = 1; e <= n; e++) {
		for (int i = 0; i <= m; i++) {
			if (dp[e-1][i] == 1) {
				if (i + shujv[e][0] <= m) {
					dp[e][i + shujv[e][0]] = 1;
				}
				if (i + shujv[e][1] <= m) {
					dp[e][i + shujv[e][1]] = 1;
				}
			}
		}
	}
	for (int e = 0; e <= m; e++) {
		cout << dp[n][e];
}
}

动态规划优化空间复杂度

#include<bits/stdc++.h>
using namespace std;
int shujv[105][2];
vector<int>dp(100005,0);
vector<int>dp2(100005, 0);
vector<int>dp3(100005, 0);
int main() {
	int n, m;
	cin >> n >> m;
	for (int e = 1; e <= n; e++) {
		cin >> shujv[e][0] >> shujv[e][1];
	}
	dp[0] = 1;
	for (int e = 1; e <= n; e++) {
		for (int i = 0; i <= m; i++) {
			if (dp[i] == 1) {
				if (i + shujv[e][0] <= m) {
					dp2[i + shujv[e][0]] = 1;
				}
				if (i + shujv[e][1] <= m) {
					dp2[i + shujv[e][1]] = 1;
				}	
			}
		}
		dp= dp2;
		dp2 =dp3;
		
	}
	for (int e = 0; e <= m; e++) {
		cout <<dp[e];
	}
}

 简单分数统计

 思路:

用了下map,就过了,挺突然的,出问题的地方在map遍历的时候不是按照插入数据的顺序,不过开始记录一下数据顺序就好了

#include<bits/stdc++.h>
using namespace std;
int a, b, c;
map<string, int>hhh;
map<string, int>ren;
vector<string>ren2;
int main() {
	cin >> a >> b >> c;
	for (int e = 1; e <= a; e++) {
		string zanshi;
		cin >> zanshi;
		ren.insert(pair<string, int>(zanshi, 1));
		ren2.push_back(zanshi);
	}
	for (int e = 1; e <= b; e++) {
		string zanshi;
		int zanshi2;
		cin >> zanshi >> zanshi2;
		hhh[zanshi] = zanshi2;
	}
	for (int e = 1; e <= c; e++) {
		string zanshi;
		string zanshi1;
		string zanshi2;
		cin >> zanshi >> zanshi1 >> zanshi2;
		if (ren[zanshi]>0) {
			if (zanshi2 == "AC") {
				ren[zanshi] += hhh[zanshi1];
			}
		}
		else {
			ren[zanshi] = -1;
		}
	}
	
	for (int e = 0; e < ren2.size(); e++) {
		map<string, int>::iterator it;
		for (it = ren.begin(); it != ren.end(); it++) {
			if (it->first == ren2[e]) {
				cout << it->first << " " << it->second - 1 << endl;
				break;
			}
			
		}
		
	}
	
}

alice的德州扑克 

 思路:

单纯if,else嵌套了一下,判别点数相同就for遍历对比

#include<bits/stdc++.h>
using namespace std;
map<int, int>hhh;
int dianshu[6];
int main() {
	int a[6], b[6];
	cin >> a[1] >> a[2] >> a[3] >> a[4] >> a[5] >> b[1] >> b[2] >> b[3] >> b[4] >> b[5];
	int panduansige = 0;
	for (int e = 1; e <= 5; e++) {
		int geshu = 0;
		for (int i = 1; i <= 5; i++) {
			if (a[e] == a[i]) {
				geshu++;
			}
		}
		dianshu[e] = geshu;
	}
	for (int e = 1; e <= 5; e++) {
		if (dianshu[e] >= 4) {
			panduansige = 1;
		}
	}
	int sange = 0;
	int liangge = 0;
	for (int e = 1; e <= 5; e++) {
		if (dianshu[e] == 3) {
			sange++;
		}
		if (dianshu[e] == 2) {
			liangge++;
		}
	}
	/*for (int e = 1; e <= 5; e++) {
		cout << b[e] << " ";
	}*/
	if (b[1]==b[2]&&b[2] == b[3]&&b[3] == b[4]&&b[4] == b[5]) {
		//cout << "HH<" << endl;
		if (a[5] == 14 && a[4] == 13 && a[3] == 12 && a[2] == 11 && a[1] == 10) {
			cout << "ROYAL FLUSH";
		}
		else {
			if (a[5] == a[4] + 1 && a[4] == a[3] + 1 && a[3] == a[2] + 1 && a[2] == a[1] + 1) {
				cout << "STRAIGHT FLUSH";
			}
			else {
				
				if (panduansige== 1) {
					cout << "FOUR OF A KIND";
				}
				else {
					if (sange == 3 && liangge == 2) {
						cout << "FULL HOUSE";
					}
					else {
						cout << "FLUSH";
					}
				}
			}
		}
	}
	else {
		if (panduansige == 1) {
			cout << "FOUR OF A KIND";
		}
		else {
			if (sange == 3 && liangge == 2) {
				cout << "FULL HOUSE";
			}
			else {
				if (a[5] == a[4] + 1 && a[4] == a[3] + 1 && a[3] == a[2] + 1 && a[2] == a[1] + 1) {
					cout << "STRAIGHT";
				}
				else {
					cout << "FOLD";
				}
			}
		}
	}
	
	

}

订单编号 

思路:

开始不知道这个题考查什么,直接列了map,查询,结果123过了,456超时;

最后把点搜索换成区间搜索,还是超时没过,迷惑,最后发现是cin和cout的问题,换成scanf和printf就好了

 map超时代码:

#include<bits/stdc++.h>
using namespace std;
map<int, int>panduan;
int main() {
	int a;
	cin >> a;
	for (int e = 0; e < a; e++) {
		int x;
		cin >> x;
		if (panduan[x] == 0) {
		panduan[x] = 1;
		cout << x<<" ";
		}
		else {
			for (int e = x + 1;; e++) {
				if (panduan[e] == 0) {
					panduan[e] = 1;
					cout << e << " ";
					break;
				}
			}
		}
	}
}

区间搜索用scanf 和printf代码:

#include<bits/stdc++.h>
using namespace std;
set<pair<int, int>>hhh;
inline void insert(int x, int y) {
	if (x < y) {
		return;
	}
	hhh.insert(make_pair(x, y));
}
int main() {
	int a;
	scanf("%d", &a);
	insert(2e9, 1);
	for (int e = 0; e < a; e++) {
		int x;
		scanf("%d", &x);
		auto its = hhh.lower_bound(make_pair(x, 0));
		if (its->second <= x) {
			printf("%d ", x);
			insert(its->first, x + 1);
			insert(x-1,its->second);
			hhh.erase(its);
		}
		else {
			printf("%d ", its->second);
			insert(its->first, its->second + 1);
			hhh.erase(its);
		}
	}
}

任务分配

思路:

用动态规划,这个和之前有个叫采药的题比较像,思路就是遍历时间数组,每次到一个点先看是这个点的数大还是前一个点的数大,如果是前一个点数大那就把前一个点的数放到这个点,如果这个点和某个事件的开始时间相符合,那就判断这个事件是否值得执行.

#define _CRT_SECURE_NO_WARNINGS
#include<bits/stdc++.h>
using namespace std;
int n;
struct s {
	int st, ed,w;
};
vector<s>a;
int main() {
	int maxx = 0;
	cin >> n;
	for (int e = 0; e < n; e++) {
		s x;
		cin >> x.st >> x.ed >> x.w;
		a.push_back(x);
		if (x.ed > maxx) {
			maxx = x.ed;
		}
	}
	vector<int>pd(maxx+1);
	for (int e = 1; e<pd.size(); e++) {
		pd[e] = max(pd[e], pd[e - 1]);
		for (int i = 0; i < n; i++) {
			if (e == a[i].st) {
				pd[a[i].ed] = max(pd[a[i].ed], pd[e] + a[i].w);
			}
		}
	}
	printf("%d", pd.back());
}

路径计数 

思路:

开始没多想,直接bfs,结果超时

#define _CRT_SECURE_NO_WARNINGS
#include<bits/stdc++.h>
using namespace std;
int tu[105][105];
int panduan[105][105] = { 0 };
queue<pair<int,int>>a;
inline void push(int x, int y) {
	a.push(make_pair(x, y));
}
int main() {
	int x;
	long long cishu=0;
	cin >> x;
	for (int e = 1; e <= x; e++) {
		for (int i = 1; i <= x; i++) {
			cin >> tu[e][i];
		}
	}
	a.push(make_pair(1, 1));
	panduan[1][1] = 1;
	while (!a.empty()) {
		int x1 = a.front().first;
		int y1 = a.front().second;
		a.pop();
		if (x1 == x && y1 == x) {
			cishu++;
			cishu = cishu%1000000007;
			continue;

		}
		
		if (x1+1<=x) {
			if (tu[x1 + 1][y1] == 1) {
			push(x1 + 1, y1);
			if (x1 + 1 != x && y1 != x) {
			panduan[x1 + 1][y1] = 1;
			}
			}
		}
		if (y1+1<=x) {
			if (tu[x1][y1 + 1] == 1 ) {
			push(x1, y1+1);
			if (x1!= x && y1+1!= x) {
				panduan[x1][y1 + 1] = 1;
			}
			}
		}
	}
	cout << cishu;
}

 换成动态规划

dp[i][j]=dp[i-1][j]+dp[i][j-1]过了

#define _CRT_SECURE_NO_WARNINGS
#include<bits/stdc++.h>
using namespace std;
int tu[105][105];
long long panduan[105][105];
queue<pair<int, int>>a;
inline void push(int x, int y) {
	a.push(make_pair(x, y));
}
int main() {
	int x;
	long long cishu = 0;
	cin >> x;
	for (int e = 1; e <= x; e++) {
		for (int i = 1; i <= x; i++) {
			cin >> tu[e][i];
		}
	}
	panduan[1][1] = 1;
	for (int e = 1; e <= x; e++) {
		for (int i = 1; i <= x; i++) {
				panduan[e][i] += panduan[e - 1][i] +panduan[e][i - 1];
				panduan[e][i] = panduan[e][i] % 1000000007;
				if (tu[e][i] == 0) {
					panduan[e][i] = 0;
				}
		}
	}
	cout << panduan[x][x];
}

顺便温习了一下dfs,当然,也是超时

#define _CRT_SECURE_NO_WARNINGS
#include<bits/stdc++.h>
using namespace std;
int tu[105][105];
int pan[105][105] = {0};
int x1;
long long jishu=0;
void dfs(int x, int y) {
	if (x == x1 && y == x1) {
		jishu++;
		jishu = jishu % 1000000007;
		return;
	}
	if (pan[x + 1][y] == 0&&tu[x+1][y]==1) {
		pan[x + 1][y] = 1;
		dfs(x + 1, y);
	}
	if (pan[x][y + 1] == 0 && tu[x][y+1] == 1) {
		pan[x][y + 1] = 1;
		dfs(x, y + 1);
	}
	pan[x][y + 1] = 0;
	pan[x + 1][y] = 0;
	return;
}
int main() {

	long long cishu = 0;
	cin >> x1;
	for (int e = 1; e <= x1; e++) {
		for (int i = 1; i <= x1; i++) {
			cin >> tu[e][i];
		}
	}
	dfs(1, 1);
	cout << jishu;
}

最大和上升子序列

 思路:

用dp从左到右扫一遍

#define _CRT_SECURE_NO_WARNINGS
#include<bits/stdc++.h>
using namespace std;
int main() {
	int n;
	cin >> n;
	int a[10005];
	int f[10005];
	for (int e = 1; e <= n; e++) {
		cin >> a[e];
		f[e] = a[e];
	}
	for (int e = 1; e <= n; e++) {
		for (int i = 1; i < e; i++) {
			if (a[e] > a[i]) {
				f[e] = max(f[e], f[i] + a[e]);
			}
		}
	}
	int ans = 0;
	for (int e = 1; e <= n; e++) {
		ans = max(ans, f[e]);
	}
	cout << ans;
}

 

唏嘘南溪
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
HtmlDIV拖拽效果源代码
12-21
实现div拖动，使用javascript实现的了，这个示例，大家可以尝试操作。 这对增强Web站点体验十分重要。
每日：代码
02-28
每日代码
WEEK2 代码源每日一题Div2
GuffRunetotem的博客
03-24 153
WEEK2 代码源每日一题Div2
week14 代码源每日一题Div2
swcj240031的博客
03-23 167
代码源每日一题Div2
div#div2
paullinjie的博客
05-20 1560
2013-06-04 16:01 提问者采纳 个人习惯问题，一方面便于阅读，了解id为div2的元素的隶属关系，其次也是为了避免冲突！ 在定义指定id元素样式时不是很明显，但是在定义指定class元素的样式的时候就显得比较重要。 例如简单的列表，主体左侧和右侧都有，为了避免样式重叠，就需要在选择器名称前加上上级（树）的前置限定。 当然，上面的这个可以不写，根据个人的编程
Xpath 用法总结
free_xiaochen的博客
12-05 2962
Xpath 用法总结
WEEK1 代码源每日一题Div2
GuffRunetotem的博客
03-20 146
代码源每日一题Div2
代码源每日一题div2 异或和
weixin_62528401的博客
09-21 131
每日一题？每日一抄！
代码源每日一题div2 特殊的正方形
听取WA声一片
05-23 212
输入n，输出n行n列的由+和.组成的正方形，其中最外面一圈全是+，第二圈全是.，...，对于第i圈，如果i是奇数，那么全是+，否则全是.。 输入格式 一行，一个整数n。 输出格式 n行，为满足题目要求的正方形。注意不要有行末空格。 样例输入 10 样例输出 ++++++++++ +........+ +.++++++.+ +.+....+.+ +.+.++.+.+ +.+.++.+.+ +.+....+.+ +.++++++.+ +........+ ++++++++++ 数据范围
clk_div2.rar_clk_div源代码_div2
09-24
本源码是分频器的VHDL,在QUARTUS2下已进行仿真和验证，
clk_div.rar_clk div_clk_div源代码
09-19
分频计数器verilog源代码,包括实验说明文档,清晰易懂.
精通DIV+CSS3网页布局与样式源代码
03-09
精通DIV+CSS3网页布局与样式的全部源代码
clk_div8.rar_clk_div8_clk源代码_数字时钟
09-19
基于vhdl语言的源代码，主要用于八位的数字时钟进行操作，会用到进位
【程序源代码】每日种草-Python全套
程序源代码
09-25 814
关键字：《我是种草囤货君、每日种草系列》 资源包正文|内容01—【概述】“野火烧不尽，春风吹又生”，最近小编我的种草欲总是挥之不去，不管别人劝阻还是自我放弃，隔几天又会浮上心头。...
代码源每日一题Div.1 (601-607)
xhyu61的博客
08-07 243
想做的事最·优·先！ ——《Lycoris Recoil》锦木千束
div2
king_fdy的博客
02-25 715
#include <iostream> #include <cstdio> #include <cstring> #include <algorithm> using namespace std; int n,m; const int N=200010; char s[N],p[N]; int g[N][30]; int main() { int ...
代码源div2 每日一题 思维+前缀和
qq_44647370的博客
05-08 107
三段式 将序列分成三段，每段和相等，不难发现，和其实就是总和/3 记总和为sum 由此我们可以利用前缀和计算序列和，找到和为sum/3和sum*2/3的点并记录下来 如果sum*2/3的点的下标大于sum/3的点的下标，那么就是组合法解 需要注意当所有元素为0的情况，这时的时间复杂度为,直接利用小学二年级学过的求和公式求和即可 #include<iostream> #include<vector> using namespace std; const int N
【C++】——Stack与Queue（含优先队列（详细解读）
最新发布
m0_74092462的博客
06-09 989
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
PHP代码：隐藏一个div
06-11
您可以使用CSS样式来隐藏一个div元素，具体代码如下： ```css div { display: none; } ``` 将上述代码添加到您的CSS文件中，或者将其添加到HTML文件中的`<style>`标签中，就可以隐藏所有div元素。如果您只想隐藏特定的div元素，可以为该元素添加一个唯一的ID或类，并将样式应用于该ID或类。例如： ```css #myDiv { display: none; } ``` 将上述代码添加到您的CSS文件中，或者将其添加到HTML文件中的`<style>`标签中，就可以隐藏具有`id="myDiv"`的div元素。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

唏嘘南溪

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值