复习Day1_

一只乌龟7

已于 2024-03-23 15:28:19 修改

阅读量147

点赞数 3

文章标签：算法 c++ 数据结构

于 2024-03-22 21:49:46 首次发布

本文链接：https://blog.csdn.net/Shuzi_master7/article/details/136952321

版权

1205. 买不到的数目 - AcWing题库

结论法：两个数a,b不能组合出的最大的数是(a-1)*(b-1)-1

#include <iostream>
#include <algorithm>
using namespace std;
int n, m, minn, maxx, ans;
bool dp[1000000];//记录每一个数是否能被凑出来
int main() {
    cin >> n >> m;
    dp[0] = true;
    minn = min(n, m);
    maxx = max(n, m);
    if(n==2&&m==3){
      cout<<1;
      return 0;
    }//特判一下
    for (int i = minn; i <= n * m; i++) {
        if (dp[i - minn]) {//减去一个数能凑出来 那么这个数也能凑出来
            dp[i] = true;
        } else if (i >= maxx && dp[i - maxx]) {
            dp[i] = true;
        } else {//减去一个数都凑不出来 那么这个数肯定也凑不出来
            ans = i;
        }
    }
    cout << ans;
    return 0;
}

1211. 蚂蚁感冒 - AcWing题库

#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int n;
int st;
int a[N];

int main(){
    cin >> n;
    int res = 1;

    for(int i = 0; i < n; i ++) cin >> a[i];
    st = a[0];

    sort(a, a + n);

    //设第一只蚂蚁为蚁后
    
    //情况一(对应例1)
    //假如蚁后朝右走
    //例如蚁后坐标为5
    //那么所有蚂蚁坐标a是负数的且abs(a) > 5的都会被感染(因为一定会碰面)
    //如果有一只如上所述的蚂蚁t，那么所有蚂蚁坐标b是正数的且b < 5的蚂蚁都会被蚂蚁t感染

    //情况二(对应例2)
    //假如蚁后朝左走
    //例如蚁后坐标为-10
    //那么所有蚂蚁坐标a是正数的且a < abs(-10)的都会被感染
    //如果有一只如上所述的蚂蚁t，那么所有蚂蚁坐标b是负数的且b < -10的蚂蚁都会被蚂蚁t感染

    if(st > 0)//往右走
    {
        for(int i = 0; i < n; i ++)
            if(a[i] < 0 && abs(a[i]) > st)//往左走且在右边的蚂蚁肯定会被感染
                res ++;

        if(res != 1)//只要感染的有蚂蚁
        {
            for(int i = 0; i < n; i ++)
                if(a[i] > 0 && a[i] < st)
                    res ++;//左边 往右走的蚂蚁肯定也会被感染
        }
    }
    
    else//往左走
    {
        for(int i = 0; i < n; i ++)//左边 往右走的蚂蚁肯定会被感染
            if(a[i] > 0 && a[i] < abs(st))
                res ++;

        if(res != 1)//只要右感染的蚂蚁
        {
            for(int i = 0; i < n; i ++)//右边 往左走的蚂蚁肯定会被感染
                if(a[i] < 0 && a[i] < st)//两个负数比较 -4<-2 但是2   4仍然大的是右边
                    
                    res ++;
        }
    }

    cout << res << '\n';
    return 0;
}

895. 最长上升子序列 - AcWing题库

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define x first
#define y second
int n;
const int N=1e3+7;
int a[N];
int dp[N];//dp[i]表示以i结尾的单增字串的长度 
void solve(){
    cin>>n;
    for(int i=1;i<=n;i++)cin>>a[i];
    for(int i=1;i<=n;i++)dp[i]=1;
    
    for(int i=1;i<=n;i++){
    	for(int j=1;j<i;j++){
    		if(a[i]>a[j])dp[i]=max(dp[i],dp[j]+1);
		}
	}
	int mx=-0x3f3f;
	for(int i=1;i<=n;i++){
		mx=max(mx,dp[i]);
	}
	cout<<mx;
}

signed main () {
    int t = 1; // cin >> t;
    while(t--) solve();
    return 0;
}

1212. 地宫取宝 - AcWing题库

//暴力写法
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define x first
#define y second
int n,m,k;
const int N=57;
const int mod=1000000007;
int cnt=0;
int a[N][N];
bool check(int x,int y){//判断是否合法
	if(x<1||y<1||x>n||y>m)return false;
	return true;
}
int mx=-0x3f3f;
void dfs(int x,int y,int take){
	if(x==n&&y==m){
		if(take==k)cnt=(cnt+1)%mod;//如果走到了 然后拿的东西是k个就可以方案数++
        if(take==k-1&&a[n][m]>mx)cnt=(cnt+1)%mod;//如果走到了 然后拿的东西是k-1且可以拿就ok
        return ;
	}
	if(take>k)return ;//拿多了肯定不行
	//向右走
	
	//如果可以拿走 ::就是大于目前已经有的物品的最大价值 
if(check(x,y+1)){
if(a[x][y+1]>mx){//有资格被拿的
	int temp=mx;
    mx=a[x][y+1];
    dfs(x,y+1,take+1);//拿 
    mx=temp;
}
dfs(x,y+1,take);//不能拿直接走
}
    //向下走
if(check(x+1,y)){
if(a[x+1][y]>mx){
	int temp=mx;
    mx=a[x+1][y];
    dfs(x+1,y,take+1);//拿 
    mx=temp;
}
dfs(x+1,y,take);
}
}
void solve(){
	cin>>n>>m>>k;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			cin>>a[i][j];
		}
	}
	dfs(1,1,0);//不拿第一个元素 直接开始走
	mx=a[1][1];//拿上第一个元素 然后开始走
	dfs(1,1,1);
	cout<<cnt;
	return ;
}
signed main () {
    int t = 1; 
    while(t--) solve();
    return 0;
}

//记忆化搜索
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007, N = 55;
int n, m, k;
int s[N][N];
int dp[N][N][20][15]; //第i，j格子里拿了num个东西 最大价值为v的方案数

int dfs(int x, int y, int num, int v){
    int &vx = dp[x][y][num][v];//记得引用
    if(vx >= 0) return vx;//如果有就直接返回就行
    if(x > n || y > m || num > k)  return 0;

    if(x == n && y == m){//当前是不是在最后一个格子
        if(num == k||(num == k-1 && s[x][y] > v))  //若在最后手中数量等于k，
                return 1;//或者最后手中数量等于k-1且最后的物品价值大于前面所有的物品价值的最大值                                             //(意思可以拿最后一件)
        else                //意思可以拿最后一件，拿了正好手中物品数量等于k
            return 0;
    }
    vx = 0;//记得归为0
    if(s[x][y] > v){//如果可以拿的话 就是拿了然后去下一个格子
        vx = (vx + dfs(x + 1, y, num + 1, s[x][y]))%M;
        vx = (vx + dfs(x, y + 1, num + 1, s[x][y]))%M;
    }
    //回来之后处理 不拿 这里也包含s[x][y]>v的情况
    vx = (vx + dfs(x, y + 1, num, v))%M;
    vx = (vx + dfs(x + 1, y, num, v))%M;
    return vx;
}

int main(){
    cin >> n >> m >> k;
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= m; j ++)
            cin >> s[i][j];

    memset(dp, -1, sizeof dp);      
    //先走到1，1然后再判段拿还是不拿
    cout << dfs(1, 1, 0, -1)%M;//注意因为最开始的价值是-1
    return 0;
}

#include <iostream>

using namespace std;
const int mod = 1e9+7;
const int N = 55;
int n, m, k, s[N][N];

int process(int curR, int curC, int curNum, int curMax){
    if(curR > n || curC > m || curNum > k) return 0; //不能越界
    if(curR == n && curC == m){ //走到终点
        if(curNum == k || (s[curR][curC] > curMax && curNum + 1 == k))//满足条件，方案数+1
            return 1;
        else
            return 0;
    }
    if(s[curR][curC] > curMax){
        return process(curR, curC + 1, curNum + 1, s[curR][curC]) +
            process(curR, curC + 1, curNum, curMax) +
            process(curR + 1, curC, curNum + 1, s[curR][curC]) +
            process(curR + 1, curC, curNum, curMax);
    }else{
        return process(curR, curC + 1, curNum, curMax) +
            process(curR + 1, curC, curNum, curMax);
    }
}

int main(){
    cin >> n >> m >> k;
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= m; j++){
            cin >> s[i][j];
        }
    }
    cout << process(1, 1, 0, -1) % mod << '\n';
    return 0;
}

#include <iostream>
using namespace std;
const int mod = 1e9+7;
const int N = 55;
int n, m, k, c, s[N][N];
long long dp[N][N][N][N];
int main(){
    cin >> n >> m >> k;
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= m; j++){
            cin >> s[i][j];
            s[i][j]++;
        }
    }
    for(int i = 1; i <= 13; i++) {//倒着走
        dp[n][m][k][i] = 1;
        if(s[n][m] > i)
            dp[n][m][k-1][i] = 1;
    }
    for(int i = n; i >= 1; i--){//倒着枚举
        for(int j = m; j >= 1; j--){
            for(int t = k; t >= 0; t--){//手里拿着t个物品
                for(int c = 13; c >= 0; c--){
                    if(i == n && j == m && (t == k || t == k-1)) continue;
                    if(s[i][j] > c){
                        dp[i][j][t][c] = (dp[i][j+1][t+1][s[i][j]] + 
                                        dp[i+1][j][t+1][s[i][j]] +
                                        dp[i][j+1][t][c] + 
                                        dp[i+1][j][t][c]) % mod;
                    }else{
                        dp[i][j][t][c] = (dp[i][j+1][t][c] + 
                                        dp[i+1][j][t][c])%mod;
                    }
                }
            }
        }
    }
    cout << dp[1][1][0][0] << '\n';
    return 0;
}