/**
1，建立冗余结点方便操作
2，设置一个前置结点，每次移动到要交换的位置前面
3，判断其后续是否还有两个结点，如果有，就调整指针（画图）

 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        auto dummy = new ListNode(-1);
        dummy->next = head;
        auto p = dummy;
        while(p->next && p->next->next)
        {
            auto a = p->next, b = a->next;
            a->next = b->next;
            b->next = a;
            p->next = b;
            p = a;
        }
        return dummy->next;
    }
};

暴力模拟

#include <bits/stdc++.h>
#define buff                     \
    ios::sync_with_stdio(false); \
    cin.tie(0);
//#define int long long
using namespace std;
const int N = 1000;
int year, month, day;
int r[30] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int p[30] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
void solve()
{
    cin >> year >> month >> day;
    bool flag = 0;
    if ((year % 4 == 0 && year % 100 != 0) || year % 100 == 0)
        flag = 1;

    if (flag)
    {
        day += 1;
        if (day > r[month])
        {
            day -= r[month];
            month++;
        }

        if (month > 12)
            month = 1, year++;
    }

    else
    {
        day += 1;
        if (day > p[month])
        {
            day -= p[month];
            month++;
        }

        if (month > 12)
            month = 1, year++;
    }

    cout << year << '-';
    if (month < 10)
        cout << 0 << month << '-';
    else 
        cout << month << '-';

    if (day < 10)
        cout << 0 << day;
    else 
        cout << day;

    cout << '\n';
}
int main()
{
    int t;
    cin >> t;
    while (t--)
        solve();
}

王道机试指南 动态规划 最长递增子序列

(动态规划) $O(n^2)$

#include<iostream>
#include<cstdio>

using namespace std;

const int MAXN = 25;

int height[MAXN];
int dp[MAXN];

int main(){
    int k;

    while(scanf("%d",&k) != EOF){
        for(int i = 0 ; i < k;i++){
            scanf("%d",&height[i]);
        }



    int answer = 0;

    for(int i = 0;i<k;i++){ 
        dp[i]=1; //初始化为1 
        for(int j = 0 ;j < i ; j++)
            if(height[i]<=height[j])//最长不增子序列条件 
            {
                dp[i]=max(dp[i],dp[j]+1);

            }

        answer = max(dp[i],answer);//每次遍历完Ai之前的Aj后更新 
    } 

    cout<<answer<<endl;

    }
    return 0; 
} 

推荐博客：http://t.csdn.cn/fkIau

解题思路：
1:假设s[i]为a[i]的前缀和数组若要求出：一段长度不超过 m 的连续子序列，使得子序列中所有数的和最大。
2:即求出s[i] - s[i - m + 1](m = 1, ..., m)的最大值
3:因为s[i]已固定, 即求出s[i - m + 1]最小值即可；
4:这里需要一个队列维护一个长度不大于m的数组，
当队列队尾的元素大于等于当前需要插入的数时，就可以把队尾删除
即维护了一个单调上升的单调队列
每次取出对头元素即为最小值

代码如下：

#include <cstdio>
#include <iostream>

using namespace std;

typedef long long LL;

const int N = 300010;

int a[N];
LL s[N];
int q[N], hh, tt;

int main()
{
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i ++ )
    {
        scanf("%d", &a[i]);
        s[i] = s[i - 1] + a[i];
    }

    LL res = -0x3f3f3f3f;
    for (int i = 1; i <= n; i ++ )
    {
        while (i - q[hh] > m) hh ++ ;//当队列中的元素数量多于m时弹出对头，
                                     //这里本应该是i - q[hh] + 1的但因为上次循环i加了一次所以需要少减一次
        res = max(res, s[i] - s[q[hh]]);//记录每次 循环的对最大值
        while (hh <= tt && s[q[tt]] >= s[i]) tt -- ;//当队列不空切队尾元素大于s[i]时弹出队尾；
        q[++ tt] = i;//经过上面的while循环此时队列中的元素一定都小于i，将i插入队尾
    }

    cout << res << endl;

    return 0;
}

#include <iostream>

using namespace std;

int main()
{
    double x;
    cin >> x;
    if (x >= 0  && x <= 100)//不能写0 <= x <= 100
    {
        if (x > 75) cout << "Intervalo (75,100]";
        else if (x > 50) cout << "Intervalo (50,75]";
        else if (x > 25) cout << "Intervalo (25,50]";
        else cout << "Intervalo [0,25]";
    }
    else cout << "Fora de intervalo";

    return 0;
}

或

#include <iostream>

using namespace std;

int main()
{
    double x;
    cin >> x;

    if (x >= 0 && x <= 25) cout << "Intervalo [0,25]";
    else if (x > 25 && x <= 50) cout << "Intervalo (25,50]";
    else if (x > 50 && x <= 75) cout << "Intervalo (50,75]";
    else if (x > 75 && x <= 100)cout << "Intervalo (75,100]";
    else cout << "Fora de intervalo";

    return 0;
}

第一种方法
第一种方法就是y总视频中讲的, 因为b较小可以被c++中的int表示, 因此我们将a*b拆解为a每一个数位上的数与b相乘, 组合而成答案

//
// Created by trudbot on 2022/7/5.
//

#include <bits/stdc++.h>

#define ll long long
#define pii pair<int, int>
using namespace std;

vector<int> eval(vector<int> a, int b)
{
    vector<int> res;
    int curr = 0;
    for(int i : a)
    {
        curr += i * b;
        res.push_back(curr % 10);
        curr /= 10;
    }
    if(curr != 0) res.push_back(curr);
    return res;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);

    string a;
    int b;
    cin >> a >> b;
    vector<int> va;
    for(int i=a.length()-1; i>=0; i--) va.push_back(a[i]-'0');

    vector<int> res = eval(va, b);
    int last = res.size()-1;
    while(last>0 && res[last] == 0) last--;
    while(last>=0) cout << res[last--];
    return 0;
}

第二种方法
第二种方法的适用性较强, 对任意长度的a和b均可使用.
以123*12举例, 将两个数从个位从0开始编号, 即
编号：2 1 0
　　　1 2 3
　　　　1 2
按我们的习惯执行乘法
编号：2 1 0
　　　1 2 3
　　　　1 2
　　 ----------
　　　2 4 6
　　1 2 3

1 4 7 6

我们可以发现, 当a中编号为i的数与b中编号为j的数相乘时, 结果一定会加到i+j编号的位置，　以此原理我们的代码就很好写了

//
// Created by trudbot on 2022/7/4.
//

#include <bits/stdc++.h>

#define ll long long
using namespace std;
typedef pair<int, int> PII;

vector<int> multiply(vector<int> va, vector<int> vb)
{
    vector<int> res;
    int la = va.size(), lb = vb.size();
    res.resize(la+lb-1);
    for(int i=0; i<la; i++)
        for(int j=0; j<lb; j++)
            res[i+j] += va[i]*vb[j];

    int carry = 0;
    for(int i=0; i<=la+lb-2; i++)
    {
        res[i] += carry;
        carry = res[i] / 10;
        res[i] %= 10;
    }
    if(carry != 0) res.push_back(carry);

    return res;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);

    string a, b;
    cin >> a >> b;
    vector<int> va, vb;
    for(int i=a.length()-1; i>=0; i--) va.push_back(a[i]-'0');
    for(int i=b.length()-1; i>=0; i--) vb.push_back(b[i]-'0');

    vector<int> res = multiply(va, vb);
    int i = res.size()-1;
    while(i>0 &&res[i] == 0) i--;
    while(i >= 0) cout << res[i--];
    return 0;
}

帮你标明了 所有 可能踩的坑！

/**
题目：合并k个有序链表
思路：
    每次要找k个有序表头的最小值
    建立一个小根堆是最快的（存储的是k个链表当前的首个结点）
    对于自定义的数据结构（ListNode），建立大根堆时需要传入排序方式（仿函数，重载调用运算符）
    实现对于结点按照p->val来排序，并且是小根堆

 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    class cmp{
    // class默认属性为private，写仿函数一定要加public，或者使用struct
    public:
        bool operator()(ListNode* a, ListNode* b)
        {
            return a->val > b->val;
        }
    };
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        priority_queue<ListNode*, vector<ListNode* >, cmp> pri;
        // 建立一个冗余结点，存储合并后的链表
        auto dummy = new ListNode(-1);
        // 向堆中存入所有链表的当前头结点
        for(auto l : lists)
            // 这里一定要判空结点，因为如果某个链表为空，头结点l是nullptr类型，没有val这个成员，插入堆时找不到比较方法 
            if(l) pri.push(l);    
        // 每次取出堆头,加入到合并后的链表，如果该结点有后续结点，要放入堆中
        auto tail = dummy;
        while(!pri.empty())
        {
            auto tmp = pri.top();
            pri.pop();
            tail = tail->next = tmp;  // 尾结点一定要记得后移，否则会反复覆盖头部
            if(tmp->next) pri.push(tmp->next);
        }
        return dummy->next;
    }
};