蓝桥-3.19

Micmic33

已于 2022-03-20 13:45:46 修改

阅读量890

点赞数

文章标签：蓝桥杯算法

于 2022-03-20 08:41:34 首次发布

本文链接：https://blog.csdn.net/weixin_53459056/article/details/123588616

版权

七段码 - 蓝桥云课 (lanqiao.cn)

#include<iostream>
using namespace std;

const int N=10;

int ans;
int P[N];	//存父节点
bool st[N];	//是否点亮该二极管
int e[N][N];//是否相邻 

//并查集的查询 
int find(int x){
	if(P[x]==x)
		return x;
	else{
		P[x]=find(P[x]);
		return P[x];
	}
} 

void dfs(int u){
	if(u==8){		//七个二极管都试探完毕 
		for(int i=1;i<=7;i++) P[i]=i; //并查集的初始化
		
		for(int i=1;i<=7;i++)
			for(int j=1;j<=7;j++)
				if(e[i][j] && st[i] && st[j])
					P[find(i)]=find(j);		//并查集的合并 
		
		int cnt=0;
		for(int i=1;i<=7;i++)	//用并查集判断是否只有一个连通块 
			if(st[i] && P[i] == i)    //一开始这个判断条件没懂，因为一开始i的父亲就是i
                                      //所以所有和i一组的父亲都是i!!!
				cnt++;
				
		if(cnt==1) ans++;
		
		return;
	}
	
	st[u]=1;	//打开第u个二极管
	dfs(u+1);
	
	st[u]=0;
	dfs(u+1);	//关闭第u个二极管 
} 

int main(){
	e[1][2] = e[1][6] = 1;
	e[2][1] = e[2][7] = e[2][3] = 1;
	e[3][2] = e[3][7] = e[3][4] = 1;
	e[4][3] = e[4][5] = 1;
	e[5][4] = e[5][7] = e[5][6] = 1;
	e[6][1] = e[6][7] = e[6][5] = 1;
	e[7][2] = e[7][3] = e[7][5] = e[7][6] = 1;

	dfs(1);
	
	cout<<ans;
	return 0;
}

本题使用了递归和并查集的知识，很有价值！

#include<iostream>
using namespace std;

int M[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};

bool Run(int y){
	if(y%4==0 && y%100!=0 || y%400==0)
		return true;
	return false;
}

int main(){
	for(int y=1900;y<=2000;y++){
		for(int m=1;m<=12;m++){
			if(Run(y)) M[2]=29;
			for(int d=1;d<=M[m];d++){
				int tem=y*10000+m*100+d;
				if(tem%2012==0 && tem%3==0 && tem%12==0){
				
					printf("%d%02d%02d",y,m,d);
					cout<<endl;
				}
			}
		}
	}
	return 0;
}

4 0 4 0 4 0 4 32 -1 -16 4 32 4 32 4 32 4 32 4 32 8 32 8 32 16 34 16 34 32 30 -64 0 
16 64 16 64 34 68 127 126 66 -124 67 4 66 4 66 -124 126 100 66 36 66 4 66 4 66 4 126 4 66 40 0 16 
4 0 4 0 4 0 4 32 -1 -16 4 32 4 32 4 32 4 32 4 32 8 32 8 32 16 34 16 34 32 30 -64 0 
0 -128 64 -128 48 -128 17 8 1 -4 2 8 8 80 16 64 32 64 -32 64 32 -96 32 -96 33 16 34 8 36 14 40 4 
4 0 3 0 1 0 0 4 -1 -2 4 0 4 16 7 -8 4 16 4 16 4 16 8 16 8 16 16 16 32 -96 64 64 
16 64 20 72 62 -4 73 32 5 16 1 0 63 -8 1 0 -1 -2 0 64 0 80 63 -8 8 64 4 64 1 64 0 -128 
0 16 63 -8 1 0 1 0 1 0 1 4 -1 -2 1 0 1 0 1 0 1 0 1 0 1 0 1 0 5 0 2 0 
2 0 2 0 7 -16 8 32 24 64 37 -128 2 -128 12 -128 113 -4 2 8 12 16 18 32 33 -64 1 0 14 0 112 0 
1 0 1 0 1 0 9 32 9 16 17 12 17 4 33 16 65 16 1 32 1 64 0 -128 1 0 2 0 12 0 112 0 
0 0 0 0 7 -16 24 24 48 12 56 12 0 56 0 -32 0 -64 0 -128 0 0 0 0 1 -128 3 -64 1 -128 0 0

#include<iostream>
#include<bitset>
#include<string>
#include<cmath>
using namespace std;

int t;
string temp;

int main() {
	//32个字节一个汉字

	//10个汉字大循环 
   	for (int i = 1; i <= 10; i++) {
		for (int i = 1; i <= 32; i++) {
			//每个汉字32字节小循环 
			for (int i = 1; i <= 2; i++) {
				cin >> t;
				bitset<8> b(t);
				string s = b.to_string();
				for (int i = 0; i < 8; i++) {
					if (s[i] == '0')
						cout << " ";
					else
						cout << "*";
				}

			}
			cout << endl;
		}

	}
	return 0;
    //最后输出的是9^9=
}

非常丑陋的动态规划...待改进

#include<iostream>
#include<bitset>
#include<string>
#include<cmath>
using namespace std; 

int main() {
	//只能向右下（含这排）方向走
	//现在在[i][j]--可能是从这些方向走来
						 //[i][j-1]  [i][j-2] [i][j-3]
						 //[i-1][j] [i-1][j-1] [i-1][j-2]
						 //[i-2][j] [i-2][j-1] 
						 //[i-3]
	int n,m;
	cin>>n>>m;
	
	int a[101][101];
	int dp[101][101]={0};
	
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++)
			cin>>a[i][j];
	}
	
	dp[1][1]=a[1][1];
	
	for(int i=1;i<=n;i++)
	for(int j=1;j<=m;j++){
		if(i==1 && j == 1)continue;
		dp[i][j] = dp[i - 1][j] + a[i][j];
			if (i - 2 >= 1) dp[i][j] = max(dp[i][j], dp[i - 2][j] + a[i][j]);
			if (i - 3 >= 1) dp[i][j] = max(dp[i][j], dp[i - 3][j] + a[i][j]);
			if (j - 1 >= 1) dp[i][j] = max(dp[i][j], dp[i][j - 1] + a[i][j]);
			if (j - 2 >= 1) dp[i][j] = max(dp[i][j], dp[i][j - 2] + a[i][j]);
			if (j - 3 >= 1) dp[i][j] = max(dp[i][j], dp[i][j - 3] + a[i][j]);
			if (i - 1 >= 1 && j - 1 >= 1) dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + a[i][j]);
			if (i - 1 >= 1 && j - 2 >= 1) dp[i][j] = max(dp[i][j], dp[i - 1][j - 2] + a[i][j]);
			if (i - 2 >= 1 && j - 1 >= 1) dp[i][j] = max(dp[i][j], dp[i - 2][j - 1] + a[i][j]);
	}
	
	cout<<dp[n][m];

}

#include<iostream>
#include<bitset>
#include<string>
#include<cmath>
using namespace std; 

bool NoTwoFour(int n){
	while(n!=0){
		if(n%10==2 || n%10==4)return false;
		n/=10;
	}
	return true;
}

int main() {
	int cnt=0;
	for(int i=1;i<=1999;i++){
		if(!NoTwoFour(i))continue;
		for(int j=i+1;j<=2019-i;j++){
			if(!NoTwoFour(j))continue;
			int k=2019-i-j;
			if(NoTwoFour(k) && k>j && k>i)
				cnt++;
		}
	}
	cout<<cnt;
}