暑期ACM-Week3（7.29-8.4）

于 2024-08-04 00:27:03 发布
阅读量431 收藏 13
点赞数 16
分类专栏： 暑期ACM 文章标签： c语言 c++ visual studio code 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_72724507/article/details/140899319
版权

文章目录


贪心算法

贪心算法（Greedy Algorithm），也称贪婪算法，是一种在每一步决策中都选择当前状态下最优的选项，以期达到全局最佳结果的优化算法。其核心思想是通过一系列局部最优选择来实现整体最优解。

定义

贪心算法的基本定义如下：
在每一步决策时，总是采取在当前状态下的最好选择，从而希望导致结果是最好或最优的。
贪心算法不考虑未来可能产生的影响，只关注当前的局部最优解。
贪心算法通常运行迅速，因为它们不涉及复杂的回溯或多次迭代。

特性

局部最优选择：在每步只选择当前看似最优的决策，不考虑长远后果。
不回溯：一旦做出选择，不会回溯或重新评估这些决策。
简单直接：由于算法逻辑简单，易于编码和快速实现。
高效性：运行迅速，因为不需要复杂的回溯或多次迭代。

原理与使用方法

贪心算法的基本原理是从问题的某个初始解出发，逐步地进行选择，直到达到最终求解的过程。每一步选择都是基于当前的局部最优，并且不能回退。因此累积到的这些局部最优的选择结果，就是全局最优解。
使用贪心算法需要满足以下两个条件：
问题具有贪心选择性质，即使用当前最优解能够得到全局最优解；
问题的子问题具有最优子结构性质，即原问题的最优解可以通过对子问题的最优解组合而得到。

设计步骤

设计贪心算法一般包括以下几个步骤：
确定问题的最优子结构；
基于问题的最优子结构设计一个递归算法；
证明我们做出的贪心选择，只剩下一个子问题；
证明贪心选择总是安全的；
设计一个递归算法实现贪心策略；
将贪心算法转化为迭代算法。

贪心算法的应用示例：

最小生成树：在加权无向图中，Prim算法和Kruskal算法都是基于贪心策略的算法，用于求解最小生成树。
活动选择问题：给定一系列活动，每个活动都有一个开始时间和一个结束时间，求可以安排的最大活动数，使得没有两个活动的时间重叠。这个问题可以通过贪心算法求解。
背包问题（部分情况）：虽然背包问题通常使用动态规划求解，但在某些特定条件下（如0-1背包问题的贪心版本，即“分数背包问题”），贪心算法也可以得到最优解。
哈夫曼编码：在数据压缩中，哈夫曼编码是一种使用贪心算法构建的用于无损数据压缩的广泛使用的可变长编码方式。
例如：在找零钱问题中，假设我们有面值为1元、5元、10元、50元、100元、500元的货币，现在要找零786元，贪心算法会从最大面额开始逐步减少，直到找到最优解。

贪心算法的优缺点：

优点：
算法简单，易于实现。
在某些问题中，能够产生最优解或近似最优解。
时间复杂度低，效率高。
缺点：
不适用于所有问题，特别是那些需要全局最优解的问题。
贪心策略的选择对结果有很大影响，如果贪心策略选择不当，可能导致无法得到最优解。

例题

P1478 陶陶摘苹果（升级版）

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e6 + 10;

struct apple{
    int high;
    int power;
}ap[N];

int cmp(apple a,apple b){
    return a.power<b.power;
}


signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);

    int n,s;//苹果数，力气
    cin>>n>>s;

    int a,b;//椅子高度，手臂长
    cin>>a>>b;

    for(int i=1;i<=n;i++){
        cin>>ap[i].high>>ap[i].power;
    }

    sort(ap+1,ap+n+1,cmp);//对苹果按照力气从小到大排序

    //摘苹果
    int ans=0;
    for(int i=1;i<=n;i++){
        //判断高度是否足够
        if(ap[i].high>a+b){//超出高度
            continue;
        }
        else if(s>=ap[i].power){
            s-=ap[i].power;
            ans++;
        }
    }
    cout << ans<<endl;
    return 0;
}

P2240 【深基12.例1】部分背包问题

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e6 + 10;

struct gold{
    int x;
    int y;
    double pj;
}jb[N];

int cmp(gold a,gold b){
    return a.pj>b.pj;
}

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int n,t;
    cin>>n>>t;

    for(int i=0;i<n;i++){
        cin>>jb[i].x>>jb[i].y;
        jb[i].pj=(double)jb[i].y/(double)jb[i].x;
    }

    sort(jb,jb+n,cmp);

    double sum=0;
    for(int i=0;i<n;i++){
        if(t>=jb[i].x){
            sum+=jb[i].y;
            t-=jb[i].x;
        }
        else if(t>0){
            sum+=(t)*jb[i].pj;
            break;
        }
    }
    cout<<fixed<<setprecision(2)<<sum;
    return 0;
}

P1803 凌乱的yyy / 线段覆盖

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e6 + 10;

struct time1{
    int x;
    int y;
} bs[N];

bool cmp(time1 a, time1 b){
    return a.y < b.y;
}

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);//关闭同步流

    int n;
    cin >> n;
    for (int i = 0; i < n;i++){
        cin >> bs[i].x >> bs[i].y;
    }

    sort(bs, bs + n,cmp);
    int cnt=0;int last = -1;
    for (int i = 0; i < n;i++){
        if(last<=bs[i].x){
            cnt++;
            last = max(last, bs[i].y);
        }
    }
    cout << cnt << endl;
    return 0;
}

P1106 删数问题

双指针

概念

双指针（Two Pointers）是一种在遍历对象过程中，使用两个指针进行访问以达到特定目的的算法思想。根据两个指针的移动方向和相对位置，可以分为以下几种类型：
快慢指针：两个指针从同一侧开始遍历数组或链表，一个指针移动速度快（快指针），另一个移动速度慢（慢指针）。这种模式常用于解决需要判断某个条件是否满足的问题，如寻找有序数组中的某个值、判断是否存在某对元素等。
对撞指针：两个指针分别从数组的两端开始向中间移动，通常一个指针向前移动，另一个向后移动。这种模式适用于需要找到一对特定条件下的元素对，例如两数之和问题。
滑动窗口：当两个指针指向同一数组且遍历方向相同且不相交时，称为滑动窗口。这种模式常用于区间搜索问题，如寻找最长的子串满足某种条件

例题

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

int main(){
    string s;cin>>s;

    int i=0,j=s.size()-1;

    while(i<j){
        if(s[i]!=s[j]){
            cout<<"No"<<endl;
            return 0;
        }
        i++;j--;
    }
    cout<<"Yes"<<endl;
    return 0;
}

找指定和的整数对

输入n个整数，放入数组a。找出其中的两个数，他们的和等于m。
输入样例：

9 28
21 4 5 6 13 65 32 9 23

输出

5 23

解题代码

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

int main(){
    int n,m;
    cin>>n>>m;
    int a[10000];
    for(int i=0;i<n;i++){
        cin>>a[i];
    }

    sort(a,a+n);

    int i=0,j=n-1;
    while(i<j){
        if(a[i]+a[j]>m){
            j--;
        }
        if(a[i]+a[j]<m){
            i++;
        }
        if(a[i]+a[j]==m){
            cout<<a[i]<<" "<<a[j]<<endl;
            i++;
        }
    }
    return 0;
}

移动0

给定一个数组nums，编写一个函数将所有0移动到数组的末尾，同时保持非零元素的相对顺序
输入：nums = [0,1,0,3,12]
输出：[1,3,12,0,0]
解题代码

int a[5] = { 0,1,0,3,12 };
int i = 0, j = 0;
while (j <= 4) {
    if (a[i] != 0) {
        i++, j++;
    }
    else if (a[j] != 0) {
        swap(a[i], a[j]);
        i++;
    }
    j++;
}
for (int i = 0; i < 5; i++) {
    cout << a[i] << " ";
}
return 0;

寻找区间和

给定一个长度为n的数组a和一个数s；在这个数组中寻找一个区间，使得这个区间的元素之和等于s，输出区间的起点和终点
输入样例：

15 6
6 1 2 3 4 6 4 2 8 9 10 11 12 13 14

输出样例

0 0
1 3
5 5
6 7

解题代码
略

A-B 数对

A-B 数对

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

#define int long long
const int maxn = 2e6+10;
int a[maxn];

signed main(){
    int n, c;
    cin >> n >> c;

    for(int i = 1; i <= n; i++) {
        cin >> a[i];
    }

    sort(a + 1, a + n + 1);

    // i 是用来枚举b
    // j and k are used to determine the interval range of a
    // i is used to determine the left endpoint of the interval
    // k is used to determine the right endpoint of the interval
    long long ans = 0;
    for(int i = 1, j = 1, k = 1; i <= n; i++) {
        while(j <= n && a[j] - a[i] < c) j++;
        while(k <= n && a[k] - a[i] <= c) k++;
        ans += k - j;
    }

    cout << ans << "\n";
    return 0;
}

前缀和与差分

概括

一维前缀和：
定义：s[i]前i项的和
构造：s[i] = s[i-1] + a[i]
使用：快速求出区间和
求出3-5之间的区间和：s[5] - s[2] = (1+2+3+4+5) - (1+2)

一维差分（标记思想）
定义：b[i]前ix项的和等于原数组a[i]
构造：b[i] = a[i] - a[i-1]
使用：快速区间修改
在3-5之间都+1，b[3]++,b[6]–
求和的时候同时进行前缀和运算即可

二维前缀和
定义：s[i][j]第i行，第j列的子矩阵的和
构造：s[i][j] = s[i-1][j] + s[i][j-1] + a[i][j] - s[i-1][j-1]
使用：快速求出矩阵中任意子矩阵（2，2）（5，5）
sum = s[5][5] - s[1][5] - s[5][1] + s[2][2]

二维差分
详见解题集：地毯

前缀和的概念和用法

概念：
前缀和是指一个数组的某下标之前的所有数组元素的和（即数列的前n项求和）。在算法中，前缀和是一种重要的预处理手段，能够降低算法的时间复杂度，快速地求出某一段的和，对于处理区间之间的问题往往十分高效。
用法：

  1. 预处理前缀和数组：首先，对原始数组进行一次遍历，累加计算出前缀和数组的每一个元素。具体实现时，可以创建一个与原始数组相同长度的前缀和数组，其中第i个元素代表原始数组从下标0到下标i-1的元素之和（或者从下标1到下标i的元素之和，具体取决于实现方式）。
  2. 查询区间和：在预处理得到前缀和数组后，可以通过计算两个位置的前缀和之差来快速得到任意区间的和。例如，对于区间[a, b]，其和等于前缀和数组中第b+1个元素（如果下标从0开始）减去第a个元素（如果a不为0）。

作用：
1.高效计算区间和：前缀和可以用来快速计算数组中某个区间的和。例如，要计算区间l,r之间的和，只需用s[r]减去s[l-1]即可。
2.二维前缀和：在处理二维数组时，如矩阵的最大子矩阵和问题，前缀和同样适用。通过预处理二维前缀和，可以大大降低查询的时间复杂度。

差分的概念和用法

概念：
差分，又名差分函数或差分运算，是数学中的一种概念，差分的结果反映了离散量之间的一种变化，是研究离散数学的一种工具。差分运算可以看作是前缀和的逆运算，它将原函数映射到其差分表示上。差分运算在数学、物理和信息学等领域有广泛应用。
用法：

  1. 构建差分数组：对于一维数组，差分数组d的每个元素d[i]表示原数组a中第i个元素与第i-1个元素的差（即d[i] = a[i] - a[i-1]，注意d[0]通常没有定义或设为0）。通过差分数组，可以方便地实现对原数组某个区间的批量加减操作。
  2. 区间修改：当需要对原数组的某个区间[l, r]内的所有元素都加上一个值c时，可以通过修改差分数组来实现。具体操作为：d[l] += c（表示从l位置开始增加c），d[r+1] -= c（表示在r+1位置结束增加，防止对后续区间产生影响）。之后，通过对差分数组进行前缀和运算，即可得到修改后的原数组。
  3. 降低时间复杂度：通过差分，可以将区间修改操作的时间复杂度从O(n)降低到O(1)（对于差分数组的修改操作）和O(n)（对于通过前缀和还原原数组的操作），从而在处理大量区间修改和查询问题时提高效率。

作用：
1.快速修改区间值：差分法主要用于对数组的某一个区间每个数加上一个常数。例如，如果要将区间l,r的所有元素赠加一个常数d,则只需将差分数组c中的c[i]加上d,并且c[r+1]减去d。
2.逆向操作：当需要对原数组进行某些特定的修改时（如在某个区间内增加或减少某个值)，可以通过差分数组来实现。首先对差分数组进行相应的修改，然后通过前缀和恢复原数组。

综上所述，前缀和与差分是算法中常用的两种技巧，它们分别通过预处理和逆运算的方式，降低了算法的时间复杂度，提高了处理区间问题的效率。
详见解题集（求区间和~最高的牛奶）
1722439460586.png

整数二分&&实数二分

原理理解

搜索法和二分法
搜索法
把区间[a, b]分成n等份，每个子区间长度是x，计算点xk = a + k*x(k=0,1,2,3,4,…,n)的函数值f(xk)，
若f(xk) = 0，则是一个实根，若相邻两点满足f(xk) * f(xk+1) < 0，则在(xk, xk+1)内至少有一个实根，可以取(xk+ xk+1)/2为近似根。　　
二分法
如果确定f(x)在区间[a, b]内连续，且f(a) * f(b) < 0，则至少有一个实根。
二分法的操作，就是把[a, b]逐次分半，检查每次分半后区间两端点函数值符号的变化，确定有根的区间。
用二分的两个条件：
上下界[a, b]确定
函数在[a, b]内单调。在这里插入图片描述

二分法复杂度
n次二分后，区间缩小到(b - a)/2n。
给定a、b和精度要求ε，可以算出二分次数n，即满足(b - a)/2n < ε。
二分法的复杂度是O(logn)的。
例如，如果函数在区间[0, 100000]内单调变化，要求根的精度是10-8，那么二分次数是44次。

整数二分

二分模板一共有两个，分别适用于不同情况。
算法思路：
假设目标值在闭区间[l, r]中， 每次将区间长度缩小一半，当l = r时，我们就找到了目标值。

int bin_search(int *a, int n, int x){  //a[0]～a[n-1]是单调递增的
    int left = 0, right = n;              //注意：不是 n-1
    while (left < right) {
        int mid = left + (right-left)/2; 
        //int mid = (left + right) >> 1;  
        if (a[mid] >= x)  right = mid;
        else    left = mid + 1;
    }                   //终止于left = right
    return left;       //特殊情况：a[n-1] < x时，返回n
}

（1）代码执行完后，left = right，即答案所处的位置。
（2）中间值mid
mid = left + (right-left)/2
mid = (left + right) >> 1
如果left + right很大，用前一种更好。
版本1：
当我们将区间[l, r]划分成[l, mid]和[mid + 1, r]时，其更新操作是l = mid + 1或者r = mid;（计算mid时不需要加1）
C++ 代码模板：

int bsearch_1(int l, int r)
{
     while (l < r)
     {
        int mid = l + r >> 1;  //等同于mid=(l+r)/2
        if (check(mid)) r = mid;
        else l = mid + 1;  //+1为避免死循环
    }
    return l;
}

版本2：
当我们将区间[l, r]划分成[l, mid - 1]和[mid, r]时，其更新操作是l = mid或者r = mid - 1;（此时为了防止死循环，计算mid时需要加1）
C++ 代码模板：

int bsearch_2(int l, int r)
{
    while (l < r)
    {
        int mid = l + r + 1 >> 1;
        if (check(mid)) l = mid;
        else r = mid - 1;
    }
    return l;
}

实数二分

const double eps =1e-7;        //精度。如果下面用for，可以不要eps
while(right - left > eps){     //for(int i = 0; i<100; i++){
    double mid = left+(right-left)/2;
    if (check(mid)) right = mid;           //判定，然后继续二分
    else            left  = mid;
}

循环用2种方法都可以：
while(right - left > eps) { ... }
for(inti = 0; i<100; i++) { ... }
如果用for循环，由于循环内用了二分，执行100次，相当于 1/2100的精度，比eps更精确。
8.2二分法.pptx

解题集

陶陶摘苹果（升级版）

P1478 陶陶摘苹果（升级版）
image.png
贪心：先将苹果根据力气从小到大排序，尽量省力；
然后开始高度判断，符合高度的就摘下来；
因为要求的是最多的苹果数量所以要尽量省力

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e6 + 10;

struct apple{
    int high;
    int power;
}ap[N];

int cmp(apple a,apple b){
    return a.power<b.power;
}

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);

    int n,s;//苹果数，力气
    cin>>n>>s;

    int a,b;//椅子高度，手臂长
    cin>>a>>b;

    for(int i=1;i<=n;i++){
        cin>>ap[i].high>>ap[i].power;
    }

    sort(ap+1,ap+n+1,cmp);//对苹果按照力气从小到大排序

    //摘苹果
    int ans=0;
    for(int i=1;i<=n;i++){
        //判断高度是否足够
        if(ap[i].high>a+b){//超出高度
            continue;
        }
        else if(s>=ap[i].power){
            s-=ap[i].power;
            ans++;
        }
    }
    cout << ans<<endl;
    return 0;
}

骑士的工作

image.png
例题中5个头和4个头要分开算，每次挑选一次骑士，之前理解错误合并计算报错；
这里用了动态数组，因为骑士只能用一次，用完则删
最后判断有没有剩余头

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e5 + 10;

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);//关闭同步流

    int n, m;
    cin >> n >> m;
    int sum=0;
    vector <int> t;
    for (int i = 0; i < n; i++){
        int tou;
        cin >> tou;//头
        t.push_back(tou);
    }

    vector <int> a;
    for (int i = 0; i < m; i++){
        int qs;
        cin >> qs;//骑士
        a.push_back(qs);
    }

    sort(a.begin(), a.end());//骑士从小到大排序
    int money=0;
    int tou = 0, qis = 0;
    int cnt = n;
    for (int i = 0; i < n; i++){//遍历头
        tou = t[i];
        int size1 = a.size();
        for (int j = 0; j < size1; j++){//遍历骑士
            qis = a[j];
            if (tou <= qis){
                money += a[j];
                a.erase(a.begin() + j);
                cnt--;
                break;
            }
        }
    }

    if(cnt>0)//头没杀完
        cout << "you died!" << endl;
    else
        cout << money << endl;
    return 0;
}

混合牛奶 Mixing Milk

image.png
贪心：为了求性价比，单价从小到大排序；
需求量 > 供给 ？全收 : 剩余部分

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e6 + 10;

struct nongmin{
int x;
int y;
double pj;
}jb[N];

int cmp(nongmin a,nongmin b){
    return a.x<b.x;
}

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int n,t;
    cin>>n>>t;//总量，个数

    for(int i=0;i<t;i++){
        cin>>jb[i].x>>jb[i].y;//x为单价y为数量
    }

    sort(jb,jb+t,cmp);//根据单价从小到大采购

    double sum=0;
    for(int i=0;i<n;i++){
        if(n>=jb[i].y){
            sum += jb[i].x * jb[i].y;
            n-=jb[i].y;
        }
        else if(n>0){
            sum += (n)*jb[i].x;
            break;
        }
    }
    cout<<fixed<<setprecision(0)<<sum;
    return 0;
}

排队接水

image.png
等待时间从小到大排序，每个人的等待时间是前面人的总和，求和平均

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e6 + 10;

struct paidui{
    int id;
    double time;
} pd[N];

int cmp(paidui a,paidui b){
    return a.time < b.time;
}

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int n;
    cin >> n;
    for (int i = 0; i < n; i++){
        cin >> pd[i].time;
        pd[i].id = i+1;
    }

    sort(pd, pd + n,cmp);

    for (int i = 0; i < n;i++){
        cout << pd[i].id << " ";
    }
    double sum = 0.00,x=0.00;
    for (int i = 0; i < n; i++){
        for (int j = 0; j < i; j++){
            x += pd[j].time;
        }
        sum += x;
        x = 0;
    }
    sum = sum / (double)n;
    cout <<endl << fixed << setprecision(2) << sum << endl;
    return 0;
}

凌乱的yyy / 线段覆盖

P1803 凌乱的yyy / 线段覆盖
image.png
为了参加更多的比赛，所以结束时间越靠前越容易参加的多
则排序结束时间，再与开始时间比较

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e6 + 10;

struct time1{
    int x;
    int y;
} bs[N];

bool cmp(time1 a, time1 b){
    return a.y < b.y;
}

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);//关闭同步流
    
    int n;
    cin >> n;
    for (int i = 0; i < n;i++){
        cin >> bs[i].x >> bs[i].y;
    }

    sort(bs, bs + n,cmp);
    int cnt=0;int last = -1;
    for (int i = 0; i < n;i++){
        if(last<=bs[i].x){
            cnt++;
            last = max(last, bs[i].y);
        }
    }
    cout << cnt << endl;
    return 0;
}

小A的糖果

image.png
如果超出，先看后者够不够？后者减少 ：后者清零前者再减少还需减的量

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e5+10;

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int n, x;
    cin >> n >> x;
    int a[N];int sum = 0;//总共要吃的糖
    cin >> a[0];//先吃第一个，否则最后一个算不到！！！
    for (int i = 1; i < n; i++){
        cin >> a[i];//糖果列表
        if (a[i] + a[i - 1] > x){//如果超出
            int cnt = a[i] + a[i - 1] - x;//要吃的量
            if(cnt>a[i]){//如果后者不够
                a[i-1] = cnt - a[i];//前者吃掉剩余的糖
                a[i] = 0;//后者清空
            }
            else{
                a[i] -= cnt;
            }
            sum += cnt;
        }
    }
    cout << sum << endl;
    return 0;
}

部分背包问题

P2240 【深基12.例1】部分背包问题
image.png
贪心：排序性价比，从大到小拿；
总重量 < 承重量 ？全拿 ：拿部分

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e6 + 10;

struct gold{
    int x;
    int y;
    double pj;
}jb[N];

int cmp(gold a,gold b){
    return a.pj>b.pj;
}

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int n,t;
    cin>>n>>t;

    for(int i=0;i<n;i++){
        cin>>jb[i].x>>jb[i].y;
        jb[i].pj=(double)jb[i].y/(double)jb[i].x;
    }

    sort(jb,jb+n,cmp);

    double sum=0;
    for(int i=0;i<n;i++){
        if(t>=jb[i].x){
            sum+=jb[i].y;
            t-=jb[i].x;
        }
        else if(t>0){
            sum+=(t)*jb[i].pj;
            break;
        }
    }
    cout<<fixed<<setprecision(2)<<sum;
    return 0;
}

铺设道路

image.png
先找最低点，然后计算比最低点多出多少，同时更新低点

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e5 + 10;

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int n;
    cin >> n;
    int a[N];
    cin >> a[0];
    int min = a[0];
    int sum = a[0];
    for (int i = 1; i < n; i++)
    {
        cin >> a[i];
        if(min<a[i]){
            sum += a[i] - min;
        }
        min = a[i];
    }
    cout << sum << endl;
    return 0;
}

今年暑假不AC

image.png
贪心：排序结束时间，比较开始时间，累计个数

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e6 + 10;

struct time1{
    int x;
    int y;
} bs[N];

bool cmp(time1 a, time1 b){
    return a.y < b.y;
}

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int n;
    while (cin >> n && n != 0)
    {
        for (int i = 0; i < n; i++)
        {
            cin >> bs[i].x >> bs[i].y;
        }

        sort(bs, bs + n, cmp);
        int cnt = 0;
        int last = -1;
        for (int i = 0; i < n; i++)
        {
            if (last <= bs[i].x)
            {
                cnt++;
                last = max(last, bs[i].y);
            }
        }
        cout << cnt << endl;
    }
    return 0;
}

回文串

image.png

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

int main(){
    string s;cin>>s;

    int i=0,j=s.size()-1;

    while(i<j){
        if(s[i]!=s[j]){
            cout<<"No"<<endl;
            return 0;
        }
        i++;j--;
    }
    cout<<"Yes"<<endl;
    return 0;
}

统计硬币

image.png

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e5 + 10;

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int t;
    cin >> t;

    while(t--){
        int n, m;
        cin >> n >> m;

        int cnt = 0;
        for (int i = 0; i <= n; i++)
        {
            for (int j = 0; j <= n - i; j++)
            {
                int k = n - i - j;
                {
                    if ( i + 2 * j + 5 * k == m)
                    {
                        cnt++;
                    }
                }
            }
        }
    cout << cnt << endl;
    }
    return 0;
}

A-B 数对

image.png

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

#define int long long
const int maxn = 2e6+10;
int a[maxn];

signed main(){
    int n, c;
    cin >> n >> c;

    for(int i = 1; i <= n; i++) {
        cin >> a[i];
    }

    sort(a + 1, a + n + 1);

    // i 是用来枚举b
    // j and k are used to determine the interval range of a
    // i is used to determine the left endpoint of the interval
    // k is used to determine the right endpoint of the interval
    long long ans = 0;
    for(int i = 1, j = 1, k = 1; i <= n; i++) {
        while(j <= n && a[j] - a[i] < c) j++;
        while(k <= n && a[k] - a[i] <= c) k++;
        ans += k - j;
    }

    cout << ans << "\n";
    return 0;
}

求区间和

image.png

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

#define int long long
#define double long double
const int maxn = 1e5 + 100;

int s[maxn];
int s2[maxn];

signed main() {
	int n; cin >> n;
	for (int i = 1; i <= n; i++) {
		cin >> s[i];
		s2[i] = s[i] + s2[i - 1];//累计前i个的和的数组
	}
	int m; cin >> m;
	for (int i = 1; i <= m; i++) {
		int l, r; cin >> l >> r;//区间
		cout << s2[r] - s2[l - 1] << endl;//前r个的和 - 前l-1个的和 == l~r之间的和
	}
	return 0;
}

最大加权矩形

1722438676798.png

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

#define int long long
#define double long double
const int maxn = 1e3 + 100;

int a[maxn][maxn];
int sum[maxn][maxn];

signed main() {
	int n; cin >> n;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			cin >> a[i][j];//导入矩阵
			sum[i][j] = sum[i - 1][j] + sum[i][j - 1] + a[i][j] - sum[i - 1][j - 1];
            //求和矩阵：左d和+上d和+自身-左上d和（重复）
		}
	}
	int maxx = -10000;
	for (int x1 = 1; x1 <= n; x1++) {
		for (int y1 = 1; y1 <= n; y1++) {
			for (int x2 = x1; x2 <= n; x2++) {
				for (int y2 = y1; y2 <= n; y2++) {
					int s = sum[x2][y2] - sum[x1-1][y2] - sum[x2][y1-1] + sum[x1-1][y1-1];
                    //坐标x2y2到x1y1的矩阵之和，要减去x1y2和x2y1的重复部分
					maxx = max(maxx, s);
				}
			}
		}
	}
	cout << maxx << endl;
	return 0;
}

语文成绩

1722438761856.png
image.png

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

#define int long long
#define double long double
const int maxn = 1e7 + 100;

//前缀和 ：某一序列前 n 项的和  (我昨天的C题就是用前缀和过的，否则会 TL)

/*
差分数组
原数组（差分数组的前缀和数组）
前缀和数组（原数组的前缀和数组）
*/
//修改差分 -> 原数组
//s2[x]+1 s2[x+1]-1 -> [x-y]

int a[maxn] = { 0 };
int b[maxn] = { 0 };

signed main() {
	int n, p; cin >> n >> p;
	for (int i = 1; i <= n; i++) {
		cin >> a[i];//原数组
	}
	while (p--) {
		int x, y, z; cin >> x >> y >> z;//调整
		b[x] += z;
		b[y + 1] -= z;//y之后不要加分，提前减去用来后续不加上
	}
	int minn = a[1] + b[1];
	for (int i = 1; i <= n; i++) {
		b[i] = b[i] + b[i - 1];//将差分数组变成原数组，根据前面的差分进行相加
		a[i] = a[i] + b[i];    //将两个数组相加//原数字加上差分
		minn = min(minn, a[i]);
	}
	cout << minn << endl;
}

地毯

1722438832678.png
image.png

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e5 + 10;

int a[2000][2000];

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int n, m;
    cin >> n >> m;
    
    int x1, y1, x2, y2;
    while(m--){
        cin >> x1 >> y1 >> x2 >> y2;

        for (int i = x1; i <= x2;i++){
            a[i][y1]++;//首列记录
            a[i][y2 + 1]--;//尾列减少截至
        }
    }
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            a[i][j] += a[i][j - 1];//根据上一排的压缩数据展开
            cout << a[i][j]<<(j < n ? " " : "\n");
        }
    }

    return 0;
}

气球涂颜色

1722438968275.png

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e5 + 10;
int x[N];
signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int n;
    while(cin >> n&&n!=0){
        fill(x, x + N, 0);
        for (int i = 0; i < n; i++)
        {
            int a, b;
            cin >> a >> b;
            x[a]++;
            x[b + 1]--;
        }
        for (int k = 1; k <= n;k++){
            x[k] += x[k - 1];
            cout << x[k] << (k < n ? " " : "\n");
        }
    }
    return 0;
}

最高的奶牛

1722439025862.png
思路
每次 [ a , b ] 颜色次数+1，典型的区间修改，最后求每个气球颜色修改次数，区间操作即对差分数组操作，对差分数组求前缀和就是原数组，因此此题差分

#include<iostream>
#include<map>
#include<algorithm>
using namespace std;

#define int long long
#define double long double
const int maxn = 1e5 + 100;

map<pair<int, int>, bool>cow;//去重
int s[maxn] = { 0 };

signed main() {
	int n, I, h, r; cin >> n >> I >> h >> r;
	// 几头  编号  高度  行
	while (r--) {
		int a, b;
		cin >> a >> b;
		if (a > b) {
			swap(a, b);
		}
		if (cow[make_pair(a, b)]) {
			continue;
		}
		s[a+1]--; s[b]++;
		cow[make_pair(a, b)] = true;
	}
	for (int i = 1; i <= n; i++) {
		s[i] = s[i] + s[i - 1];
		cout << s[i] + h << "\n";
	}
	return 0;
}

纪念品分组

image.png
贪心：一组两个，则先从小到大排序，再头尾选择组合，累计组数

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e5 + 10;

int a[N];
signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int w;
    cin >> w;
    int n;
    cin >> n;
    int cnt = 0;
    for (int i = 0; i < n; i++){
        cin >> a[i];
    }

    sort(a, a + n);

    int i = 0, j = n - 1;
    while(i<=j){
        if(i==j){
            cnt++;
            break;
        }
        if(a[i]+a[j]<=w){
            cnt++;
            i++;
            j--;
        }
        else{
            j--;
            cnt++;
        }
    }
    cout << cnt << endl;
    return 0;
}

小 E 与美食

image.png
贪心：满意度从大到小排序，先吃前面，计算max

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 3e5 + 10;

bool cmp(int a, int b){
    return a > b;
}
int a[N];

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

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

    sort(a, a + n, cmp);

    double sum=0.00,pj=0.00,max=0.00;
    for (int j = 0; j < n;j++){
        sum += a[j];
        pj = (double)(sum * sum) / (double)(j+1);
        if(pj>max){
            max = pj;
        }
    }
    cout << fixed << setprecision(8) << max << endl;
    return 0;
}

机器猫斗恶龙

image.png
控制血条，如果负了就累加到初始值

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e5 + 10;

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int n;
    cin >> n;
    int sum=0, max=0;
    int xt = 0;
    for (int i = 0; i < n; i++)
        {
            int x;
            cin >> x;
            xt += x;
            if(xt<0 && -1*xt>max){
                max = xt * -1;
            }
        }
    cout << max + 1 << endl;
    return 0;
}

做题

image.png
天数越多题目越多，先题库从小到大排序，然后符合就看下一天

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e6 + 10;

int a[N];
signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int n;
    cin >> n;

    for (int i = 1; i <= n; i++)
        {
            cin >> a[i];
        }

    sort(a+1, a + n+1);

    int k = 1;
    int cnt = 0;
    for (int i = 1; i <=n; i++)
        {
            if(a[i]>=k){
                k++;
            }
        }
    cout << k-1 << endl;
    return 0;
}

学生分组

image.png
先要考虑边缘问题，总共低于下限或高于上限都不行；
然后考虑调整，则考虑超出和缺少的数量，优先考虑下限缺少部分

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e5 + 10;

int a[60];

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int n;
    cin >> n;
    for (int i = 0; i < n; i++)
        {
            cin >> a[i];
        }
    int l, r;
    cin >> l >> r;
    int sum = 0;
    for (int i = 0; i < n; i++)
        {
            sum += a[i];
        }
    if (sum < n * l || sum > n * r)
    {
        cout << "-1";
        return 0;
    }
    int more = 0, less = 0;
    for (int i = 0; i < n; i++)
        {
            if(a[i]>r){
                more += (a[i] - r);
            }
            if(a[i]<l){
                less += (l - a[i]);
            }
        }
    cout << (less > more ? less : more) << endl;
    return 0;
}

连续自然数和

image.png
遍历，双指针，多了减左边，少了加右边

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e6 + 10;

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int n;
    cin >> n;
    int p1 = 0, p2 = 1;
    int sum = p1+p2;
    while(p1<p2&&p2<=n){
        if(sum==n){
            cout << p1 << " " << p2 << endl;
            sum -= p1;
            p1++;
        }
        if (sum > n){
            sum -= p1;
            p1++;
        }
        if(sum<n){
            p2++;
            sum += p2;
        }
    }

    return 0;
}

宝箱

image.png
从大到小排序，双指针，求最高和最低的差值，求符合条件的区间的和的max；
如果只是取第一个和后面符合差值比较会报错，理解题目错误，因为可能第一个很大超出差值，导致数量少总和不一定多

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e6 + 10;
int a[1010];

bool cmp(int a, int b){
    return a > b;
}

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int n, k;
    cin >> n >> k;

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

    sort(a, a + n,cmp);

    int p1 = 0, p2 = 1;
    int sum = a[p1];
    int cz = 0;
    int max = 0;
    while(p1<p2&&p2<=n){
        cz = a[p1] - a[p2];
        if (cz > k){
            if(sum>max){
                max = sum;
            }
            sum -= a[p1];
            p1++;
        }
        if(cz <= k){
            sum += a[p2];
            p2++;
        }
    }
    cout << max << endl;
    return 0;
}

排列排序

image.png

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int maxn=1e6;
int a[maxn];
signed main()
{
	int t;
	cin>>t;
	while(t--){
		int n;
		cin>>n;
		for(int i=1;i<=n;i++){
			cin>>a[i];
		}
		int i=1;
		int ans=0;
		while(i<=n){//所有数1对1对应且连续
			if(a[i]==i) i++;//数字在原来该在的位置
			else{//没有在原来位置，则开始记录区间
            //找到乱序中最大的数，因为要排到他原来位置，所有长度即为就要排序的长度
				int maxx=a[i];
				int j=i+1;
				maxx=max(maxx,a[j]);
				while(maxx>j){//找最大值原来的位置，至少到这个位置都要重新排序
					j++;
					maxx=max(maxx,a[j]);
				}
				ans+=j-i+1;
				i=j+1;//更新区间
			}
		}
		cout<<ans<<endl;
	}
}

合并果子 / [USACO06NOV] Fence Repair G

image.png
双向队列先进先出，但是这里排序了，从小到大（省力），
取出两个小的合并成大的，因为要再次合并，则重新放入数组，
每次合并前端小的两个数字最省力

#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
#define ll long long int
int main() {
	int n;
	cin >> n;
	int t;
	priority_queue<int,vector<int>,greater<int> > a;
	for (int i = 0; i < n; i++) {
		cin >> t;
		a.push(t);
	}
	int sum = 0;
	for (int i = 0; i < n - 1; i++) {
		int sum1 = 0;
		sum1 += a.top();
		a.pop();
		sum1 += a.top();
		a.pop();
		sum += sum1;
		a.push(sum1);
	}
	cout << sum;
	return 0;
}

最大正方形

image.png
二维前缀和&&二维差分，创建两个二位数组，一个放原数据，一个放前缀和数据，
后续两个坐标之间的数据和则用差分处理；
因为数据1or0，则坐标之间的数据和则为边长积（面积）

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e6 + 10;

int a[1000][1000], sum[1000][1000];

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int n, m;
    cin >> n >> m;

    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            cin >> a[i][j];
            sum[i][j] = sum[i - 1][j] + sum[i][j - 1] + a[i][j] - sum[i - 1][j - 1];
        }
    }

    int max = 0;
    for (int x1 = 1; x1 <= n;x1++){
        for (int y1 = 1; y1 <= m;y1++){
            for (int x = 0; x <= (n-x1); x++)
            {
                int x2 = x1 + x;
                int y2 = y1 + x;
                int s = sum[x2][y2] - sum[x2][y1 - 1] - sum[x1 - 1][y2] + sum[x1 - 1][y1 - 1];
                if(s==(x+1)*(x+1)&&(x+1)>max)
                    max = x+1;
            }/* 
            for (int x2 = x1; x2 <= n; x2++)
            {
                int len = x2 - x1 + 1;
                int y2 = y1 + len - 1;
                int s = sum[x2][y2] - sum[x2][y1 - 1] - sum[x1 - 1][y2] + sum[x1 - 1][y1 - 1];
                if (s == len * len && len > max)
                {
                    max = len;
                }
            } */
        }
        
    }
    cout << max;

    return 0;
}

一元三次方程求解

image.png

#include <bits/stdc++.h>
using namespace std;
int main(){
    double a, b, c, d;
    scanf("%lf%lf%lf%lf", &a, &b, &c, &d);
    double l, r, m, x1, x2;
    int s = 0;
    for (int i = -100; i < 100; i++){
        l = i;
        r = i + 1;
        x1 = a * l * l * l + b * l * l + c * l + d;
        x2 = a * r * r * r + b * r * r + c * r + d;
        if (!x1){
            printf("%.2lf ", l);
            s++;
        }
        if (x1 * x2 < 0){
            while (r - l >= 0.001){
                m = (l + r) / 2;
                if ((a * m * m * m + b * m * m + c * m + d) * (a * r * r * r + b * r * r + c * r + d) <= 0)
                    l = m;
                else
                    r = m;
            }
            printf("%.2lf ", r);
            s++;
        }
    }
}

立方根

1722601433396.png

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e6 + 10;

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int n;
    cin >> n;

    int i=0, j=sqrt(n);
    while (i<j) {
        int mid = i + (j-i+1)/2;
        if(fabs(mid*mid*mid)<=n)
            i = mid;
        else
            j = mid-1;
    }
    cout << i << endl;
    return 0;
}

机器人繁殖

1722601510186.png

python

def f(z, n):  
    if z == 1:  
        return n + n * 2 - 1  
    return f(z - 1, 2 * n - 1) + n  

def main():  
    import sys  
    input = sys.stdin.read  
    data = input().split()  
    n = int(data[0])  
    s = int(data[1])  

    l = 0  
    r = 100  
    while l < r:  
        m = (l + r) // 2  
        if f(n, m) >= s:  
            r = m  
        else:  
            l = m + 1  

    print(l)  

if __name__ == "__main__":  
    main()

小车问题

1722660438478.png

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e6 + 10;
const double eps =1e-7;

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    double s, a, b;
    cin >> s >> a >> b;

    double l,r, t1, t2, tj, ty, m;
    l = 0;
    r = s;
    do{
        m = (l+r) / 2.0;
        t1 = m / b;
        t2 = (m - t1 * a) / (a + b);
        tj = t1 + (s - m) / a;
        ty = t1 + t2 + (s - (t1 + t2) * a) / b;
        if (tj < ty)
            r = m;
        else
            l = m;
    }while (fabs(tj - ty) > 1e-8);
    cout << fixed << setprecision(6) << tj << endl;
    return 0;
}

小玉在游泳

1722700421935.png

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e6 + 10;
const double eps =1e-7;

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    double s;
    cin >> s;

    double sum = 0.00;
    int cnt = 0;
    double x = 2.0;
    while(sum<s){
        sum += x;
        cnt++;
        x *= 0.98;
    }
    cout << cnt << endl;
    return 0;
}

Sanitize Hands

1722700518989.png

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e6 + 10;
const double eps =1e-7;
int a[N];
signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int n, m;
    cin >> n>>m;

    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
    }

    int cnt = 0;
    for (int i = 1; i <= n;i++){
        if(m>=a[i]){
            m -= a[i];
            cnt++;
        }
        else
            break;
    }
    cout << cnt << endl;
    return 0;
}

Subsegment Reverse

image.png

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e6 + 10;
const double eps =1e-7;

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int n, l, r;
    cin >> n >> l >> r;

    vector<int> a;
    for (int i = 1; i <=n; i++){
        a.push_back(i);
    }
    if(l!=r)
        reverse(a.begin()+l-1, a.begin()+r);

    for (int i = 0; i < n; i++){
        cout << a[i] << (i < n - 1 ? " " : "\n");
    }
    return 0;
}

Adjacent Product

image.png

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e6 + 10;
const double eps =1e-7;
int a[N], b[N];
signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int n;
    cin >> n;
    for (int i = 0; i < n; i++){
        cin >> a[i];
    }
    for (int i = 0; i < n-1; i++){
        b[i]=a[i]*a[i+1];
        cout<<b[i]<<(i < n - 1 ? " " : "\n");
    }
    return 0;
}

Uppercase and Lowercase

image.png

#include<bits/stdc++.h>  
using namespace std;  
#define int long long  
#define endl "\n"  
const int N = 1e6 + 10; // 注意这个常量在代码中没有直接使用，但定义也没问题  
const double eps = 1e-7; // 这个常量同样在代码中没有使用  

signed main(){  
    ios::sync_with_stdio(false);  
    cin.tie(nullptr);  
    cout.tie(nullptr);  

    string s, sx = "", sk = ""; // 初始化 sx 和 sk 为空字符串  
    cin >> s;  

    int a = 0, b = 0;  
    for(char x : s){  
        if(x >= 'a' && x <= 'z'){  
            a++;  
            sx += x;  
            sk += (x - 'a' + 'A'); // 将小写转换为大写并添加到 sk  
        }  
        else if(x >= 'A' && x <= 'Z'){ // 确保只处理大写字母  
            b++;  
            sx += (x - 'A' + 'a'); // 将大写转换为小写并添加到 sx  
            sk += x;  
        }  
    }  
    if(a > b){  
        cout << sx << endl; // 输出小写字母组成的字符串  
    }  
    else{  
        cout << sk << endl; // 输出大写字母组成的字符串  
    }  
    return 0;  
}

Nutrients

1722700849856.png

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e6 + 10;
const double eps =1e-7;
int a[1000],x[1000][1000],sum[1000];
signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int n, m;
    cin >> n >> m;

    for (int i = 1; i <= m; i++){
        cin >> a[i];
    }
    memset(sum, 0, sizeof(sum));
    for (int i = 1; i <= n; i++){
        for (int j = 1; j <= m; j++){
            cin >> x[i][j];
            sum[j] += x[i][j];
        }
    }
    for (int z = 1; z <= m;z++){
        if(a[z]>sum[z]){
            cout << "No" << endl;
            return 0;
        }
    }
    cout << "Yes" << endl;
    return 0;
}

Piano

image.png

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e6 + 10;
const double eps =1e-7;

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int w, b;
    cin >> w >> b;

    string s = "wbwbwwbwbwbw";

    for (int i = 0; i < 12; i++) {
        int numw = 0, numb = 0;//w的数量，b的数量
        //以i，j为双指针，j移动w+b的长度；
        for (int j = 0; j < w + b; j++) {
            if (s[(i + j) % 12] == 'w') numw++;
            else numb++;
        }
        //ij子集若满足条件则yes
        if (w == numw and b == numb) {
            cout << "Yes" << endl;
            return 0;
        }
    }
    cout << "No" << endl;
}

Sierpinski carpet

image.png

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e6 + 10;
const double eps =1e-7;

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int n,l=1;
    char a[729][730];
    for(int i=0;i<729;i++)for(int j=0;j<730;j++)a[i][j]=0;

    cin>>n;
    a[0][0]='#';
    for(int k=0;k<n;k++){
        for(int x=0;x<3;x++){
            for(int y=0;y<3;y++){
                if((x==0)&&(y==0))continue;
                if((x==1)&&(y==1)){
                    for(int i=0;i<l;i++)for(int j=0;j<l;j++)a[x*l+i][y*l+j]='.';
                }
                else{
                    for(int i=0;i<l;i++){
                        for(int j=0;j<l;j++){
                            a[x*l+i][y*l+j]=a[i][j];
                        }
                    }
                }
            }
        }
        l*=3;
    }

    for(int i=0;i<l;i++)cout<<a[i]<<endl;

    return 0;
}

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

int x;
char s[2005][2005];

void fill(int x, int y, int k) {
	if (k == 0) return s[x][y] = 1, void();
	int t = k / 3;
	fill(x, y, t);
	fill(x + t, y, t);
	fill(x + t * 2, y, t);
	fill(x, y + t, t);
	fill(x, y + t * 2, t);
	fill(x + t, y + t * 2, t);
	fill(x + t * 2, y + t, t);
	fill(x + t * 2, y + t * 2, t);
}

signed main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr), cout.tie(nullptr);
	cin >> x;
	if (x == 0) return cout << "#", 0;
	int t = pow(3, x);
	fill(1, 1, t);
	for (int i = 1; i <= t; i++) {
		for (int j = 1; j <= t; j++) cout << (s[i][j] == 0 ? '.' : '#');
		cout << '\n';
	}
	return 0;
}

Rudolf and the Ugly String

image.png

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e6 + 10;
const double eps =1e-7;

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);cout.tie(nullptr);

    int t;
    cin >> t;
    while(t--){
        int n;
        cin >> n;
        string s;
        cin >> s;
        int cnt=0;
        for (int x = 0; x < n-2;x++){
            if(s[x]=='m'&&s[x+1]=='a'&&s[x+2]=='p'){
                cnt++;
                x += 2;
            }
            else if(s[x]=='p'&&s[x+1]=='i'&&s[x+2]=='e'){
                cnt++;
                x += 2;
            }
        }
        cout << cnt << endl;
    }
    return 0;
}
云书景Yskye
关注
  • 16
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ACM-CheatSheet：ACM-ICPC模板
02-03
ACM-ICPC备忘单 ACM-ICPC模板特征维护模板代码，自动生成PDF， 代码高亮，代码中渲染数学公式可直接插入tex文件仅包含一个文件的目录，会引入文件直接作为一个章节已有模板仅作为参考用法模板代码遵循/src目录下的...
ACM-数据结构-并查集学习
02-20
ACM-数据结构-并查集学习
解决问题：ACM-Reference-Format使用这个style后，文献引用顺序和正文不一致
丨汀、的博客
12-02 7159
解决问题：latex中bib引用顺序不正确，引用顺序和正文不一致_丨汀、的博客-CSDN博客问题：生成pdf时文献应用会乱序引用bib格式的参考文献时，会这么写：\bibliographystyle{plain}\bibliography{%filename%.bib}而plain的意思是用作者的姓名排序，而不是按照引用顺序，解决方案：所以推荐改成\bibliographystyle{unsrt}按照bib中出现顺序来排序总结：1. plain，按字母的顺序排列，比较次序为作者、年度和标题2. unsrt，
ACM-Reference-Format如何改成文献引用顺序和正文一致
qq_42792820的博客
05-09 766
教你解决ACM-Reference-Format模板乱序问题
【LaTex】11 ACM参考文献顺序引用 - 解决 ACM-Reference-Format 顺序不符合论文实际引用顺序的问题
定期分享我的发现和想法，感谢你的陪伴和支持
05-28 2904
第一种解决方案则通过直接修改 .bst 文件中的排序设置，彻底禁用了默认的排序规则，使得参考文献能够按照我们引用的顺序出现。这种方法简单直接，适合不需要复杂排序功能的情况。 第二种解决方案的关键在于使用 natbib 宏包和适当配置的 .bst 文件。natbib 宏包提供了强大的引用管理功能，能够处理引用排序和格式问题。而通过配置 .bst 文件，我们可以确保参考文献按照实际引用的顺序排列，而不是默认的字母顺序。
ACM-ICPC算法汇总【基础篇】
佛系更新
06-15 7351
本篇博客包含ACM，NOIP所涉及的基础算法，涵盖七个模块：基础算法，数据结构，搜索与图论，STL，数学知识（数论），动态规划，贪心。涵盖内容范围较为全面，是面向初学者的算法汇总，第八个章节是所涉及的算法板子，可以直接使用。因为是面向算法竞赛，本文的所有设计算法都是用C++进行实现的，不提供其他语言的代码，共涉及106道算法题目，以题代讲，在题目中理解算法的内涵。
2021-2022 ACM-ICPC Latin American Regional Programming Contest
apple_52197802的博客
04-26 3317
J. Joining Pairs 思路: 本题显然答案为NNN的情况为两条线段的顶点都出现在矩形边框上且连接会相交。其余为YYY。 如何判断连接会相交？我们可以把二维的矩形转化为一维来写 inline int go(int x, int y){ if(y == 0) return x; if(x == n) return n + y; if(y == m) return m + 2 * n - x; if(x == 0) return (n + m) * 2 - y;
acm--今年暑假不AC(纯c语言)
qq_45473786的博客
08-02 3175
这里写自定义目录标题题目分析代码 题目 “今年暑假不AC？” “是的。” “那你干什么呢？” “看世界杯呀，笨蛋！” “@#$%^&*%…” 确实如此，世界杯来了，球迷的节日也来了，估计很多ACMer也会抛开电脑，奔向电视了。 作为球迷，一定想看尽量多的完整的比赛，当然，作为新时代的好青年，你一定还会看一些其它的节目，比如新闻联播（永远不要忘记关心国家大事）、非常6+7、超级女生，以及王小...
Latex中ACM-Reference-Format顺序与论文引用顺序不一致solution
hm__2016的博客
10-30 3942
2. 在之后的编译中，使用\bibliographystyle{ACM-Reference-Format}编译.注意，之后要是引用有增加删除都需要重复12的步骤；
计算机竞赛acm试题,ACM-ICPC 2018 总决赛赛题
weixin_39762075的博客
07-13 4158
原标题：ACM-ICPC 2018 总决赛赛题2018 年 4 月 19 日，第 42 届国际大学生程序设计竞赛全球总决赛在北京大学(中国·北京)成功举办。ACM 国际大学生程序设计竞赛(ACM International Collegiate Programming Contest，简称 ACM-ICPC)由国际计算机协会(ACM)主办，旨在展示大学生创新能力、团队精神和在压力下编写程序、分析和...
2017-2018 ACM-ICPC, NEERC, Northern Subregional Contest
axuhongbo的博客
11-18 1190
SDUT 2017 Autumn Team Contest 19th 题解汇总[Gym-101612I] [Problem I] I - Intelligence in Perpendicularia 计算在多边形内部可以看到，但在外部看不到的线条长度思路：利用容斥原理，先计算多边形的总周长，再减去露在外面的最长部分
「ACM-ICPC基础算法」
qq_45992664的博客
02-25 3148
本系列文章为ACM-ICPC基础算法系列！
基于C++的ACM-ICPC模板
02-22
【标题】：“基于C++的ACM-ICPC模板” 在计算机编程竞赛中，特别是国际大学生程序设计竞赛（ACM-ICPC）中，拥有一套高效、灵活且经过优化的编程模板是至关重要的。这个“基于C++的ACM-ICPC模板”集合了一套专门为...
个人ACM-ICPC模板acm-icpc-master.zip
02-05
标题中的“个人ACM-ICPC模板acm-icpc-master.zip”指的是一个与ACM国际大学生程序设计竞赛（International Collegiate Programming Contest, ICPC）相关的个人开发的模板项目。这个压缩包很可能是参赛者或者教练为了...
ACM-ICPC-制备：ACM-ICPC制备指南
02-02
《ACM-ICPC制备：ACM-ICPC制备指南》 在计算机科学领域，ACM国际大学生程序设计竞赛（ACM International Collegiate Programming Contest，简称ACM-ICPC）是一项备受瞩目的赛事，它挑战参赛者的编程技能、算法理解...
C语言——函数
attitude_lu的博客
08-01 778
函数的主要思想是：函数其实是从上到下逐步求解的过程，把一个大的问题拆成多个小的子问题或者说把一个大的功能拆成小的功能模块，通过实现小的功能最终实现大的功能的过程。
C语言100道基础拔高题（1）
2303_78660417的博客
07-23 3568
最后按最小值，中间值，最大值的顺序打印即可。解题思路：首先输出由这几个数字所组成的所有三位数，接着再设置条件，使其输出的三位数不重复，下面我们来看下源代码。值得注意的是：所以题目的代码都是作者自行编写，如有更好的思路或者代码的优化，还请指出更正。解题思路：首先找到能整除这个正整数的最小正数，接着重置循环初值，让它继续查找最小正数，最后将得到的所有正数放到一个数组里，最后设置好格式之后循环打印出来。解题思路：首先确定好区间，接着判断是否是素数，素数就是一个大于1的数，除了1和它本身之外，不能被其他数整除。
C语言 ——— 学习、使用 strcat函数 并模拟实现
最新发布
weixin_55341642的博客
08-02 238
字符串的内容不会被改变，所以可加上 const 关键字修饰。source 字符串后面的字符依次向后追加，且。字符串的空间要足够大，能容纳下追加的。中的字符串结束标志 '\0' 被。source 字符串，否则就会报错。字符串的 '\0' 也要追加上。
【C++】输入输出
2401_83948390的博客
08-02 321
在C++中，输入输出操作主要通过标准库中的iostream头文件提供的一系列对象和函数来完成。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值