#include <bits/stdc++.h>
using namespace std;
const int N=17;
int n;
bool vis[N];//记录某一个数是否出现过
void dfs(int dep){
// if(vis[dep])continue;//没有这一句 因为一定不会有已经选过的数
if(dep==n+1){//对于每个数都做完了选与不选的决定
for(int i=1;i<=n;i++){
if(vis[i])cout<<i<<' ';
}
cout<<'\n';
return ;//记得要return
}
vis[dep]=1;
dfs(dep+1);
vis[dep]=0;
dfs(dep+1);
}
int main(){
cin>>n;
dfs(1);
return 0;
}#include <bits/stdc++.h>
using namespace std;
const int N=100;
int a[N];
int n,m;//n个数中选择m个
int vis[N];
void dfs(int dep,int st){//st数组是为了保证顺序每次只往后面找
if(dep==m+1){//选够m个数了 该选第m+1个数了
for(int i=1;i<=n;i++){
if(vis[i]==1)cout<<a[i]<<" ";
}
cout<<'\n';
return ;
}
for(int i=st;i<=n;i++){
if(!vis[i]){
vis[i]=1;//这层有一个数 才去搜索下一层(重要)
dfs(dep+1,i+1);//这里是i+1 因为第i个数字做出判断之后下次要判断的应该是它后面的数
vis[i]=0;
}
}
}
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++)a[i]=i;
dfs(1,1);
return 0;
}#include <bits/stdc++.h>
using namespace std;
const int N=17;
int n;
bool vis[N]={};//记录某一个数是否出现过
vector<int>ans;
void dfs(int dep){//这里的dep表示的是够多少个数
if(dep==n+1){
for(auto i:ans)cout<<i<<' ';
cout <<'\n';
return ;
}
for(int i=1;i<=n;i++){
if(vis[i])continue;
vis[i]=1;
ans.push_back(i);
dfs(dep+1);//这里要是搜索下一个位置 一定要是dep+1
vis[i]=0;
ans.pop_back();
}
}
int main(){
cin>>n;
dfs(1);
return 0;
}#include <bits/stdc++.h>
using namespace std;
const int N=17;
int n;
bool vis[N]={};//记录某一个数是否出现过
vector<int>ans;
void dfs(int dep,int st){//这里的dep表示的是够多少个数
if(dep==n+1){
for(auto i:ans)cout<<i<<' ';
cout <<'\n';
return ;
}
for(int i=st;i<=n;i++){
if(vis[i])continue;
vis[i]=1;
ans.push_back(i);
dfs(dep+1,st+1);//这里要是搜索下一个位置 一定要是dep+1
vis[i]=0;
ans.pop_back();
}
}//这样的意思是从第一个数开始搜 答案一定要够n个数才能输出
int main(){
cin>>n;
dfs(1,1);
return 0;
}1537. 递归实现排列类型枚举 II - AcWing题库
#include <bits/stdc++.h>
using namespace std;
const int N=12;
int a[N],vis[N];
int n;
vector<int>ans;
void dfs(int dep){
if(dep==n+1){
for(int i=0;i<n;i++)cout<<ans[i]<<" \n"[i==n-1];
return ;
}
for(int i=1;i<=n;i++){
if(!vis[i]){
vis[i]=1;
ans.push_back(a[i]);
dfs(dep+1);
ans.pop_back();
vis[i]=0;
while(a[i + 1] == a[i]) i++;//剪去重复的 每一个数后面会分出来不同的枝，
//使相同的数分出来的相同枝只出现一次，可以避免重复输出
}
}
return ;
}
int main(){
cin>>n;
for(int i=1;i<=n;i++)cin>>a[i];
sort(a+1,a+n+1);
dfs(1);
return 0;
}
#include <bits/stdc++.h>
using namespace std;
int n,q;
const int N=100007;
int a[N];
int dp[N];
void solve(){
dp[1]=0;
dp[2]=1;
dp[3]=1;
for(int i=4;i<=n;i++)dp[i]=dp[i-1]+dp[i-2];
for(int i=1;i<=n;i++)cout<<dp[i]<<' ';
}
int main(){
int t=1;
cin>>n;
while(t--)solve();
return 0;
}唯一分解定理：一个数可以由若干个质数的若干次方相乘得到
也可以通过若干个2的次方相加得到
好难啊这题我哭死了
#include <bits/stdc++.h>
using namespace std;
const int N = 6;
int dx[N] = {-1, 0, 1, 0, 0}, dy[N] = {0, 1, 0, -1, 0};
char g[N][N], backup[N][N];
// 这个操作是把(x, y)以及上下左右的灯都变成相反的颜色
void turn (int x, int y)
{
for (int i = 0; i < 5; i ++ )
{
int a = x + dx[i], b = y + dy[i];
//如果在边界外边，直接忽略即可
if (a < 0 || a >= 5 || b < 0 || b >= 5) continue;
g[a][b] ^= 1; //异或，不同的时候就变成相反的数
//同0异1
}
}
int main()
{
int n;
scanf("%d", &n);
while(n -- )
{
// 按行输入，把每一行当成一个字符串
for (int i = 0; i < 5; i ++ ) cin >> g[i];
int res = 0x3f3f;
// 这里我们枚举了第一行的32种按法，不用管是亮是灭，把第一行所有情况都按一遍
// 按每种情况的第一行，去遍历接下来的行
// 枚举32种第一行的按法只是可能会减少步数，如果直接从第二行开始答案一定是固定的了，找不到最优解或者可能没有解
//枚举第一行的意义是：不需要在意第一行的灯是灭是暗，只需把第一行的按法枚举一遍，也就是我们说的 “操作”，
//每个位置都有两种选择，按(用1表示)或者不按(用0表示)，遍历这32种操作引发的情况，
//每一次再通过res = min(res, step);把最小步数存一下，就能找到最优解
for (int op = 0; op < 32; op ++ ){//枚举第一行每一种状态 //好好想想这里为什么要是<32：11111是31
//是说我们输入的已知的是第一行灯亮或暗的状态，而我们枚举的32种是我们对灯的操作，按还是不按。
// 我在对这种情况操作的时候，得先备用一下
// 把原始数组备份一下，然后操作g，操作完了还原，然后再操作
memcpy(backup, g, sizeof g);
int step = 0;
// 第一行的按法(在这里 1 表示按了, 0 表示不按)，这里只是为了输出第一行按完之后的状态
for (int i = 0; i < 5; i ++ )
if (op >> i & 1) // 数字2 对应了 00010 表示第2个位置的按一下
// 00010 >> 1 & 1 是1 所以turn(0, 1) 就是第一行第二个位置
{ // 数字3 对应了00011 表示第1 和第2个位置的按一下
step ++ ;
turn (0, i);;
}
// 然后通过第一行按完之后的状态，按234行
for (int i =0; i < 4; i ++ )
for (int j = 0; j < 5;j ++ )
if (g[i][j] == '0')
{
step ++;
turn (i + 1, j); // 如果这个位置是灭的，就按下一行对应的位置
}
bool dark = false;
for (int j = 0; j < 5; j ++ )
if (g[4][j] == '0')
{
dark = true;
break;
}
// 对于32种情况的这一种，如果所有的全亮就记录下步数(事实上只记录了最后一行是否dark)
if (!dark) res = min(res, step);
memcpy (g, backup, sizeof g);
}
if(res > 6) res = -1;
cout << res << endl;
}
return 0;
}//一个把手改变，会使所在行列的所有把手全部反转
//特点：①在最优解里面每个把手只按一次，按两次没有区别，
//②按的顺序无关紧要，最终取决于这个把手按的次数！！！
//思考这个题可以递推出来吗？ 答案是：很难
//可以想一想，前面的题都是通过某种顺序，每一次都是影响一个灯泡，但是这个题
//不能使用前面的办法，因为操作一次会影响好多灯泡。所以想一想朴素做法
//我们发现这个题的数据范围很小，所以尝试用暴力解决ac
//暴力思路：①16个开关，所有开关的状态数量想一想是多少？ 答案是2^16！这个我感觉
//我这么笨还是可以想出来的，往后怎么想呢？
//状态数量即最大操作次数2^16（65536）,既然也不大，那就①枚举所有的方案，
//然后按照这个方案来操作
//②如果可以实现把手全开，证明此方案合法
//③然后统计这个方案里面需要操作的把手数量
//④在所有能按的开关数量里取一个最小值
//ac
//输出方案注意:若两种方案步数相同，按字典序（先按横坐标排序，再按纵坐标排序）
#include <bits/stdc++.h>
//这个宏定义其实也就最后输出的时候应用了（如果我没猜错的话），但是y总的习惯就是好习惯！
#define x first
#define y second
using namespace std;
typedef pair<int,int> PII;
const int N=5;
char g[N][N],backup[N][N];
//映射函数
int get(int x,int y){
return x*4+y;//返回第x行第y列上的数是多少
}
void turn_one(int x,int y){
if(g[x][y]=='+') g[x][y]='-';
else g[x][y]='+';
}
void turn_all(int x,int y){
for(int i=0;i<4;i++)
{
turn_one(x,i);//关闭这一行所有的
turn_one(i,y);//关闭这一列的全部
//xy被关闭了两次 相当于没变
}
turn_one(x,y);//对xy也要改变
}
int main(){
for(int i=0;i<4;i++)
for(int j=0;j<4;j++)
cin>>g[i][j];
vector<PII> res;//这是记录方案所需要的结构
//枚举所有的方案
for(int op=0;op<(1<<16);op++){//枚举每一种方案 1代表我们要去操作那个灯
vector<PII> temp;//temp里面存的是方案
//先备份一下，为什么？因为这又不是最终方案，我们要把所有方案都试一遍，求最少的
memcpy(backup,g,sizeof g);
//枚举16个位置,进行操作
for(int i=0;i<4;i++)
for(int j=0;j<4;j++)
if(op>>get(i,j)&1) //如果当前位置是1(我们在方案中准备操作)的话--get的作用就是返回二进制数中那一位是第几位，从而判断是否为1
{
temp.push_back({i,j});
//按一下开关
turn_all(i,j);
}
//判断所有灯泡是否全亮
bool has_closed=false;
for(int i=0;i<4;i++)
for(int j=0;j<4;j++)
if(g[i][j]=='+') has_closed=true;
if(has_closed==false)
{
//如果方案为空或者他的操作数大于我们刚存好的新的方案，那么就修改它
if(res.empty()||res.size()>temp.size()) res=temp;
}
//还原回来，供下一个方案操作
memcpy(g,backup,sizeof g);
}
//因为没说无解，所以可以猜想一下一定有解
cout<<res.size()<<'\n';
//这里的迭代函数就是一种简便写法，不要误解
//另外原题下标从1开始，所以下面加1了
for(auto op:res) cout<<op.x+1<<" "<<op.y+1<<'\n';
//for(int i=0;i<res.size();i++){
// cout<<res[i].x+1<<" "<<res[i].y+1<<'\n';
//}
return 0;
}#include <bits/stdc++.h>
using namespace std;
const int N=107;
char change(char &ch){
if(ch=='*') return 'o';
return '*';
}
char a[N];
char b[N];
int main(){
//读不进去可以尝试 cin>>s+1,cin>>s,cin.ignore(),getline(cin,a),cin.getline(a,N);
cin.getline(a,N);
cin.getline(b,N);
// cin>>(a+1);
// cin>>(b+1);
int n = strlen(a);
int step = 0;
for(int i = 0; i < n; i++){
if(a[i] != b[i]){
a[i] = change(a[i]);
if(i+1 < n) {
a[i+1] = change(a[i+1]);
}
step++;
}
}
cout << step;
return 0;
}
