蓝桥杯AcWing 题目题解 - 数学与简单DP

目录

AcWing 1230. K倍区间 - 数学优化

AcWing 1205. 买不到的数目 - 数学公式定理

 AcWing 1211. 蚂蚁感冒 - 数学思想

AcWing 1237. 螺旋折线 - 数学找规律

AcWing 2. 01背包问题 - 经典DP二维

AcWing 895. 最长上升子序列 - 经典DP一维

AcWing 822. 走方格 - 经典DP优化

---

AcWing 1230. K倍区间 - 数学优化

枚举 O(n3)
可以很简单的写出暴力代码，直接三重循环

for(int r = 1; r <= n; r ++)
    for(int l = 1; l <= r; l ++)
    {
        int sum = 0;
        for(int i = l; i <= r; i ++)
            sum += a[i];
        if(sum % k == 0) ans ++;
    }

枚举左右区间端点l,r，求出区间和sum判断是否为k的倍数，然后记录在答案ans上。
可以看出第三重循环的作用就是算出区间[l,r]的和，所以用前缀和来优化这重循环。

前缀和 O(n2)
预处理一下数组a[]，将前缀和存入s[]中，每次查询就只需要O(1)的时间了

for(int i = 1; i <= n; i ++) s[i] = s[i - 1] + a[i]; // 求前缀和

for(int r = 1; r <= n; r ++)
    for(int l = 1; l <= r; l ++)
        if((s[r] - s[l - 1]) % k == 0) ans ++;

但是这个时间还是会炸，所以还需要优化一层。

数学 O(n)
第二层循环的作用是枚举左端点，写出来就是(s[r] - s[0 ~ r - 1]) % k = 0,当这个条件成立答案就加一。

化简:

s[r]%k≡s[0 ~ r−1]%k
现在这个式子的意思就是：在模k的情况下，之前所有点和当前点有多少个相等。
所以再开一个额外的数组cnt[]记录每个前缀和取余k的余数的数量，遍历一遍就行了。

代码 O(n)

#include<iostream>

using namespace std;

typedef long long LL;

const int N = 100010;

int n, k;
LL s[N];
int cnt[N];

int main()
{
    scanf("%d%d", &n, &k);
    for(int i = 1; i <= n; i ++)
        scanf("%d", s + i), s[i] += s[i - 1];   //求前缀和

    LL ans = 0;
    cnt[0] = 1; //初始化
    for(int i = 1; i <= n; i ++)
    {
        ans += cnt[s[i] % k];   
        cnt[s[i] % k] ++;   // 前缀和取余k的余数的数量
    }
    cout << ans << endl;
}

这里要注意初始化cnt[0] = 1，因为上一步中l的取值范围是[0, r - 1]。（纯摘抄y总的笔记）

一个调试方法：

exit（0）；作用是让程序停止，用二分法检验代码哪个位置出错

AcWing 1205. 买不到的数目 - 数学公式定理

小明开了一家糖果店。

他别出心裁：把水果糖包成4颗一包和7颗一包的两种。

糖果不能拆包卖。

小朋友来买糖的时候，他就用这两种包装来组合。

当然有些糖果数目是无法组合出来的，比如要买 10 颗糖。

你可以用计算机测试一下，在这种包装情况下，最大不能买到的数量是17。

大于17的任何数字都可以用4和7组合出来。

本题的要求就是在已知两个包装的数量时，求最大不能组合出的数字。

输入格式

两个正整数 n，m，表示每种包装中糖的颗数。

输出格式

一个正整数，表示最大不能买到的糖数。

数据范围

2≤n,m≤1000
保证数据一定有解。

输入样例：

4 7

输出样例：

17

裴蜀定理：

若a,b是整数,且gcd(a,b)=d，那么对于任意的整数x,y,ax+by都一定是d的倍数，特别地，一定存在整数x,y，使ax+by=d成立。

它的一个重要推论是：a,b互质的充分必要条件是存在整数x,y使ax+by=1.

结论：

如果a,b均是正整数且互质，那么由ax + by,  x≥0,y ≥0不能凑出的最大数是(a-1)(b-1) -1。

一、打表找规律方法:

#include <iostream>

using namespace std;

int n,m;

bool dfs(int x){
    if(x==0)
        return true;

    if(x>=n&&dfs(x-n))return true;
    if(x>=m&&dfs(x-m))return true;

    return false;
}

int main(){
    int s=0;

    cin>>n>>m;

    for(int i=0;i<1000;i++){
        if(!dfs(i))
            s=i;
    }

    cout<<s;
}

找到规律后

#include <iostream>
using namespace std;
int main()
{
    int p,q;
    cin >> p >>q;
    cout <<(p - 1)*(q - 1)- 1 << endl;
    return 0;
}

二、dp算法

#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(minn>1)
        ans=1;
    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;
}

 AcWing 1211. 蚂蚁感冒 - 数学思想

长 100 厘米的细长直杆子上有 n 只蚂蚁。

它们的头有的朝左，有的朝右。

每只蚂蚁都只能沿着杆子向前爬，速度是 1 厘米/秒。

当两只蚂蚁碰面时，它们会同时掉头往相反的方向爬行。

这些蚂蚁中，有 1 只蚂蚁感冒了。

并且在和其它蚂蚁碰面时，会把感冒传染给碰到的蚂蚁。

请你计算，当所有蚂蚁都爬离杆子时，有多少只蚂蚁患上了感冒。

输入格式

第一行输入一个整数 n 表示蚂蚁的总数。

接着的一行是 n 个用空格分开的整数 Xi, Xi 的绝对值表示蚂蚁离开杆子左边端点的距离。

正值表示头朝右，负值表示头朝左，数据中不会出现 00值，也不会出现两只蚂蚁占用同一位置。

其中，第一个数据代表的蚂蚁感冒了。

输出格式

输出1个整数，表示最后感冒蚂蚁的数目。

数据范围

1<n<50
0<|Xi|<100

输入样例1：

3
5 -2 8

输出样例1：

1

输入样例2：

5
-10 8 -20 12 25

输出样例2：

3

运用一个数学思想：因为蚂蚁完全相同，所以碰撞时调头等价于穿过，只是感冒+1；

第一个蚂蚁向右走的情况：

1.右边向左走的，必然被感染

2.右边向右走，必然不会被感染

3.左边向左走，必然不会被感染

4.左边向右走:
        (1）右边存在向左走，则必然被感染
        (2)右边不存在向左走，则必然不会被感染

#include<iostream>
#include<cmath>
using namespace std;
int n;
int x[51];
int main()
{
    cin>>n;
    for(int i=0;i<n;i++) cin>>x[i];
    
    int left=0 , right =0;    //分别表示左边向右走的蚂蚁数量，和右边向左走的蚂蚁数量

    for(int i=1;i<n;i++)
    {
        if(abs(x[i])<abs(x[0])&&x[i]>0) left++;
        else if(abs(x[i])>abs(x[0])&&x[i]<0) right++;
    }
    if(x[0]>0&&right==0||x[0]<0&&left==0) cout<<1<<endl;    //无法相撞的情况
    else cout<<left +right +1<<endl;
    
}

AcWing 1237. 螺旋折线 - 数学找规律

如下图所示的螺旋折线经过平面上所有整点恰好一次。

 思路：

因为数据范围为2*10^9，模拟必然TLE，只能用数学公式

 通过找规律，得出如图标识。只需要通过坐标确定是哪一条边的第几层，与角坐标计算就可以得出。

AC码：

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
int main()
{
    int x,y;
    cin>>x>>y;
    
    if(abs(x)<=y)    //上边
    {
        int n=y;
        cout<<(LL)(2*n-1)*(2*n)+x-(-n)<<endl;
    }
    else if(abs(y)<=x)    //右边
    {
        int n=x;
        cout<<(LL)(2*n)*(2*n)-y+x<<endl;
    }
    else if(abs(x)<=abs(y)+1&&y<0)    //下边
    {
        int n=abs(y);
        cout<<(LL)(2*n)*(2*n+1)-x-y<<endl;
    }
    else    //左边
    {
        int n=abs(x);
        cout<<(LL)(2*n-1)*(2*n-1)-x+y-1<<endl;
    }
    return 0;
}

最保险的方式是把对应边角的特判全部加上， 不然可能因为判断顺序问题出错

AcWing 2. 01背包问题 - 经典DP二维

输入样例

4 5
1 2
2 4
3 4
4 5

输出样例：

8

核心套路

(1)状态f [ i ] [ j ]定义:前i个物品，背包容量j下的最优解（最大价值)∶
当前的状态依赖于之前的状态，可以理解为从初始状态 f[0][0] = 0开始决策，有N件物品，
则需要N次决策，
每一次对第 i 件物品的决策，状态 f[i][j] 不断由之前的状态更新而来。

(2）当前背包容量不够(j<v[i])，没得选，因此前i个物品最优解即为前i―1个物品最优解：

对应代码:f[i][j]= f[i - 1][j]；

(3）当前背包容量够，可以选，因此需要决策选与不选第i个物品:
·选:f[i][j] = f[i - 1][j - v[i]] +w[i]；
。不选: f[i][j] = f[i - 1][j]；
·我们的决策是如何取到最大价值，因此以上两种情况取max()。
 

#include<iostream>
using namespace std;
const int N=1010;
int v[N],w[N];  //体积，价值
int f[N][N];    //j体积下i个物品的最大价值

int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>v[i]>>w[i];
    
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
        {
            //当前背包容量装不下第i个物品，则价值等于前i-1个物品
            if(j<v[i])
                f[i][j]=f[i-1][j];
            
            //能装，进行决策是否选择第i个物品
            else
                f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i]);
                
        }
    cout<<f[n][m]<<endl;
    return 0;
}

总结：

AcWing 895. 最长上升子序列 - 经典DP一维

给定一个长度为 N 的数列，求数值严格单调递增的子序列的长度最长是多少。

输入格式

第一行包含整数 N。

第二行包含 N 个整数，表示完整序列。

输出格式

输出一个整数，表示最大长度。

数据范围

1≤N≤1000
−109≤数列中的数≤109

输入样例：

7
3 1 2 1 8 5 6

输出样例：

4

(暴力枚举) O(n2)
状态表示 dp[i]
集合： 所有以第i个数字结尾的上升子序列的集合
属性： 集合中的子序列长度的最大值
状态计算
        枚举上升子序列的倒数第二数，不妨以坐标j表示，若 a[j] < a[i] 则 dp[i] =max(dp[i], dp[j] + 1)
备注
        需要注意的是dp的长度取法不同， 对应的a[j] a[i]的坐标细节不同

#include <iostream>

using namespace std;

const int N = 1010;

int n;
int w[N], dp[N];
int mx;     // 找出所计算的dp[i]之中的最大值，边算边找
int main() {
    cin >> n;
    for (int i = 0; i < n; i++) cin >> w[i];

   
    for (int i = 0; i < n; i++) {
        dp[i] = 1;    // 设f[i]默认为1，找不到前面数字小于自己的时候就为1
        for (int j = 0; j < i; j++) {
            if (w[i] > w[j]) dp[i] = max(dp[i], dp[j] + 1);    
            // 从第一个到倒数第二个满足条件的长度为dp[j]，+1为加自己本身
        }
        mx = max(mx, dp[i]);
    }

    cout << mx << endl;
    return 0;
}

AcWing 822. 走方格 - 经典DP优化

输入样例：

2 3

输出样例：

10

 算法1
暴搜 O(2^(n+m))

#include <bits/stdc++.h>    
using namespace std;

int n, m;
int res;                  

void dfs(int x, int y)    
{
    if (x == n && y == m) // 如果搜到了点 (n, m), 那么 res ++ 并返回
    {
        res ++ ;
        return ;
    }
    if (x < n) dfs(x + 1, y); // 如果不是最下面的点，那么搜该点下面的点
    if (y < m) dfs(x, y + 1); // 如果不是最右边的点，那么搜该点右边的点
}

int main()
{
    scanf("%d %d", &n, &m);
    dfs(0, 0);            // 从点 (0, 0) 开始爆搜
    printf("%d\n", res);
    return 0;
}

数据范围不大，可以使用爆搜，但是一般来说数据范围不会这么小，所以多数情况用暴搜会超时

 算法2

动态规划O(nm)
f[i][j] 表示走到点 (i,j) 的方案数，由于每次只能往下走或往右走，所以点 (i,j) 只能从点 (i−1,j) 或点 (i,j−1) 上走过来
所以走到点 (i,j) 的方案数是走到点 (i−1,j) 的方案数与走到点 (i,j−1) 的方案数之和，推出 f[i][j]=f[i−1][j]+f[i][j−1]
边界：f[i][0]=f[0][j]=1

#include<iostream>
using namespace std;

int n, m;
int f[11][11];

int main()
{
    scanf("%d %d", &n, &m);
    for (int i = 0; i <= n; i ++ )
        for (int j = 0; j <= m; j ++ )
            if (!i || !j) f[i][j] = 1; 
            else    f[i][j] = f[i - 1][j] + f[i][j - 1]; 
    printf("%d\n", f[n][m]);
    return 0;
}