该用户太懒，这里啥也没写 (´・ω・｀)

提示：

继续往下看，会有更好看的东东！

打表过样例，暴力出奇迹 要是想把分数偷，贪心打表加暴搜 快读快写火车头，马上AC不用愁!

分不在低，一百就行；学不在深，考试则灵；斯是教室，惟吾开心……有书声之悦耳，有复习 之开心。杨奕辰（本人）云：“吾只爱数学考试！！！”

这个小伙想败家，

钱都不知怎么花，

小伙每天特别烦，

钱多根本花不完。

小伙本是单身狗，

房子票子都没有。

小伙丝毫不在意，

还和寡妇去约会。

这天小伙刚睡醒，

约了寡妇看电影。

打开手机去订票，

一看顿时吓一跳。

现在金钱贬了值，

两毛就能开奔驰。

想住豪华大别墅，

一块就能当首付。 （未完待续）

妙记珠穆朗玛峰

在猪的墓地上，狼和马都疯了。 在猪的墓地上，有狼和马蜂。

春敏

春天固然美丽 ，但是花粉过敏。 喷嚏阿嚏阿嚏 ，鼻涕流个不停。

1+1=?

A.2 B.10 C.11 D.不知道

• 答案:↓
• 啊啊啊
• 不不不
• 踩踩踩
• 顶顶顶
• 呃呃呃
• 烦烦烦
• 嘎嘎嘎
• 哈哈哈
• 哎哎哎
• 急急急
• 酷酷酷
• 啦啦啦
• 买买买
• 你你你
• 哦哦哦
• 啪啪啪
• 钱钱钱
• 日日日
• 杀杀杀
• 她她她
• 有有有
• 喂喂喂
• 嗡嗡嗡
• 嘻嘻嘻
• 也一样
• 在这种
• 啊啊啊
• 不不不
• 踩踩踩
• 顶顶顶
• 呃呃呃
• 烦烦烦
• 嘎嘎嘎
• 哈哈哈
• 哎哎哎
• 急急急
• 酷酷酷
• 啦啦啦
• 买买买
• 你你你
• 哦哦哦
• 啪啪啪
• 钱钱钱
• 日日日
• 杀杀杀
• 她她她
• 有有有
• 喂喂喂
• 嗡嗡嗡
• 嘻嘻嘻
• 也一样
• 在这种
• 啊啊啊
• 不不不
• 踩踩踩
• 顶顶顶
• 呃呃呃
• 烦烦烦
• 嘎嘎嘎
• 哈哈哈
• 哎哎哎
• 急急急
• 酷酷酷
• 啦啦啦
• 买买买
• 你你你
• 哦哦哦
• 啪啪啪
• 钱钱钱
• 日日日
• 杀杀杀
• 她她她
• 有有有
• 喂喂喂
• 嗡嗡嗡
• 嘻嘻嘻
• 也一样
• 在这种
• 啊啊啊
• 不不不
• 踩踩踩
• 顶顶顶
• 呃呃呃
• 烦烦烦
• 嘎嘎嘎
• 哈哈哈
• 哎哎哎
• 急急急
• 酷酷酷
• 啦啦啦
• 买买买
• 你你你
• 哦哦哦
• 啪啪啪
• 钱钱钱
• 日日日
• 杀杀杀
• 她她她
• 有有有
• 喂喂喂
• 嗡嗡嗡
• 嘻嘻嘻
• 也一样
• 在这种

智商:A.10,B:5,C:7,D:无法描述

0⁰ = ?

0⁰ = 0¹ / 0¹ = 0 / 0 = ? 0ⁿ = 0ⁱ⁺ⁿ / 0ⁱ =0 / 0 = ?

编程实用模版（更新中...）

1.最长非连续(上升/不上升/下降/不下降)子序列求解（时间复杂度最佳）**1.最长非连续(上升/不上升/下降/不下降)**子序列求解（时间复杂度最佳）

// O(nlogn) 复杂度求解
// 例：最长上升子序列 

#include <bits/stdc++.h>

using namespace std;
const int N = 1000005;
int n, ans, a[N], d[N], f[N];

int max_len(int x) //求解d数组中第一个(大于/大于等于/小于/小于等于)x的数下标
{
    int l = 1, r = n, mid, ans = n + 1;

    while (l <= r)
    {
        mid = (l + r) / 2;
    
        // if (d[mid] > x) //最长不下降子序列
        // if (d[mid] <= x) //最长下降子序列
        // if (d[mid] < x) //最长不上升子序列
        // if (d[mid] >= x) //最长上升子序列
        if (d[mid] >= x)
		{
            ans = mid;
            r = mid - 1;
        }
        else
            l = mid + 1;
    }
    return ans;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
  
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
        d[i] = 1000000; //最长(上升/不下降)子序列
        //d[i] = 0; //最长(下降/不上升)子序列
    }
  
    for (int i = 1; i <= n; i++)
    {
        int now = max_len(a[i]); //求解下标
        f[i] = now;
        d[now] = a[i];
        ans = max(f[i], ans); //更新ans
    }
  
    cout << ans;
  
    return 0;
}

2.最长山峰子序列/峡谷子序列（非连续）（第一个的变体）**2.最长山峰子序列/**峡谷子序列（非连续）（第一个的变体）

// O(n*n)
// 例：山峰子序列 

#include <bits/stdc++.h>

using namespace std;
int n, ans, a[105], f[105], g[105];

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);

    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> a[i];
  
    for (int i = 1; i <= n; i++)
    {
        f[i] = 1;
        for (int j = 1; j < i; j++)
        {
        	// if (a[j] < a[i]) // 山峰子序列(先上升后下降最长子序列) 
        	// if (a[j] > a[i]) // 峡谷子序列(先下降后上升最长子序列) 
		    if (a[j] < a[i])
                f[i] = max(f[i], f[j] + 1);
        }
    }
    for (int i = n; i >= 1; i--)
    {
        g[i] = 1;
        for (int j = n; j > i; j--)
        {
    	    // if (a[j] < a[i]) // 山峰子序列(先上升后下降最长子序列) 
        	// if (a[j] > a[i]) // 峡谷子序列(先下降后上升最长子序列) 
		    if (a[j] < a[i])
                g[i] = max(g[i], g[j] + 1);
    	}
	}
    for (int i = 1; i <= n; i++)
        ans = max(ans, f[i] + g[i] - 1);

    cout << ans << endl;
  
    return 0;
}

3.归并排序**3.**归并排序

逆序对定义：对于给定的一段正整数序列，如果排在前面的一个数字大于后面的数字，那么这两个数字就组成了一个逆序对。

//归并排序 O(nlogn)

#include <bits/stdc++.h>

using namespace std;

const int N = 5005;
int n, a[N], t[N];

void Mergesort(int l, int r)
{
    //1.只剩一个元素时返回
    if (l == r)
        return ;
    int mid = (l + r) / 2;
  
    //2.平分出两半进行分别处理
    Mergesort(l, mid);
    Mergesort(mid + 1, r);
  
    //3.合并 a[l ~ mid] 和 a[mid + 1 ~ r] 的两个有序数组
    int pl = l;
    int pr = mid + 1;
    int pt = l;
    while (pl <= mid && pr <= r)
    {
        // 降序 if(a[pl] >= a[pr])
        if (a[pl] <= a[pr]) {
            t[pt++] = a[pl++];
        } else {
            t[pt++] = a[pr++];
    		//逆序对 ans += mid - pl + 1;
		}
	}
    //4.处理剩余的 pl 或 pr 部分
    while (pl <= mid)
        t[pt++] = a[pl++];
    while (pr <= r)
        t[pt++] = a[pr++];
  
    //5.将 t 数组重新覆盖 a 数组
    for (int i = l; i <= r; i++)
        a[i] = t[i];
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
  
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> a[i];
    Mergesort(1, n);
  
    for (int i = 1; i <= n; i++)
        cout << a[i] << ' ';
  
    return 0;
}

4.01背包+完全背包+分组背包𝑑𝑝（动态规划）4.01背包**+完全背包+分组背包dp（动态规划）**

//优化空间复杂度(一维数组)

#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 5;
int n, m, v[101], w[101], f[N];

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
  
    cin >> m >> n;
    for (int i = 1; i <= n; i++)
        cin >> v[i] >> w[i];
  
    // 填满背包的做法补充:
	// memset(f, 0xcf, sizeof(f));
    // f[0] = 0; 
  
  
    // f[j]:在前 i 件物品中,选出总体积不超过 j 的物品,能够获得的最大价值
    // 由于 f[j] 需要从 f[j - v[i]] 转移而来,所以遍历 j 时应从大到小遍历
    for (int i = 1; i <= n; i++) {
        for (int j = m; j >= v[i]; j--) {
            f[j] = max(f[j], f[j - v[i]] + w[i]);
        }
    }
    cout << f[m];
    // cout << max(f[m], 0); 
  
    return 0;
}

//完全背包(空间压缩版)
#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 5; //范围任意
int t, k, v[N], w[N], f[N];

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
  
    //输入
    cin >> t >> k;
    for (int i = 1; i <= k; i++)
        cin >> v[i] >> w[i];
  
    for (int i = 1; i <= k; i++)
        for (int j = v[i]; j <= t; j++) //从前往后便利
        //保证在使用f[j]时已经确定i - 1个物品的状态
            f[j] = max(f[j], f[j - v[i]] + w[i]);
    cout << f[t] << endl;
  
    return 0;
}

//分组背包dp(空间压缩版)

#include <bits/stdc++.h>

using namespace std;

const int N = 1e3 + 5;
int n, m, s[N], f[N]; //f[j]表示前i个物品花费j元的最大价值
int v[N][N], w[N][N]; //如果数组过大可考虑vector存储如下
vector v[N], w[N]; //读入用v[].push_back()

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
  
    //输入
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        cin >> s[i];
        //有n组物品,每组有s[i]个物品
        for (int j = 1; j <= s[i]; j++)
            cin >> v[i][j] >> w[i][j];
    }
    for (int i = 1; i <= n; i++)
        for (int j = m; j >= 0; j--) //倒叙遍历确保f[j - v[i][j]]还没更新
            for (int k = 1; k <= s[i]; k++)
                if (j >= v[i][k]) //饭钱不能比兜里的贵啊！
                    f[j] = max(f[j], f[j - v[i][k]] + w[i][k]);
    cout << f[m];
  
    return 0;
}

5.快速幂**5.**快速幂

//快速幂 O(log2 n) 

#include <bits/stdc++.h>
#define ll long long

using namespace std;

ll b, p, k, ans = 1;
ll b1, p1;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
  
    //计算 b ^ p mod k 的结果
    cin >> b >> p >> k;
    b1 = b;
    p1 = p;
    while (p)
    {
        // 1.判断二进制情况下最后一位是否为 1
        if (p & 1)
        {
            // 2.判断为真时,计算乘积并取模
            ans *= b;
            ans %= k;
        }
        // 3.其他情况下累加 b 计算下一次的 1 并对其取模
        b *= b;
        b %= k;
    
        // 4.取出 p 的最后一位
        p >>= 1;
    }
  
    // 5.输出时 ans 别忘取模
    cout << ans % k;
  
    return 0;
}

6.最大字段和𝑑𝑝6.最大字段和dp

#include <bits/stdc++.h>

using namespace std;

const int N = 200005;
int n, a[N], f[N];
int ans = -10005;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
  
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
        f[i] = max(a[i], a[i] + f[i - 1]);
        ans = max(ans, f[i]);
    }
  
    cout << ans;
  
    return 0;
}

7.快速排序**7.**快速排序

//快速排序 quick sort
//时间复杂度：O(nlogn) ~ O(n²)
//稳定性：不稳定

#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 5;
int n, a[N];

void qsort(int l, int r)
{
    int x = a[(l + r) / 2]; //设定基准数x
    int i = l, j = r;       //设定左右边界i,j
    while (i <= j)
    {
        //升序
        while (a[i] < x) i++;
        while (a[j] > x) j--;
    
        //降序
        //while (a[i] > x) i++;
        //while (a[j] < x) j--;
    
        if (i <= j) //如果还没有交叉
        {
            swap(a[i], a[j]); //交换两个数
            i++;
            j--;
        }
    }
    if (l < j) qsort(l, j); //左端是否到底
    if (i < r) qsort(i, r); //有段是否到底
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
  
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    } qsort(1, n);
  
    for (int i = 1; i <= n; i++) {
        cout << a[i] << " ";
    }
    
    return 0;
}

8.快读快写**8.**快读快写

//T 为输入输出数据类型

inline T Read()  {
	int sum = 0, fl = 1;
	int ch = getchar();
	for (; !isdigit(ch); ch = getchar())
	if (ch == '-') fl = -1;
	for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
	return sum * fl;
}

inline void Write(T x)  {
    static int sta[35];
    int top = 0;
    do {
        sta[top++] = x % 10, x /= 10;
    } while (x);
    while (top) putchar(sta[--top] + 48); // 48 是 '0'
}

9.冒泡排序**9.**冒泡排序

/**冒泡排序(加入了判断是否已经排序了的boolean变量) */
    public static void bubbleSort(int[] arr) {
        for(int end = arr.length-1; end > 0; end--){
            boolean isSort = true;
            for(int i = 0; i < end; i++){
                if(arr[i] > arr[i+1]){
                    swap(arr,i,i+1);
                    isSort = false;
                }
            }
            if(isSort)break;
        }
    }

10.鸡尾酒排序**10.**鸡尾酒排序

/**改进的冒泡排序(鸡尾酒排序)  就是把最大的数往后面冒泡的同时，　最小的数也往前面冒泡*/
    public static void cocktailSort(int[] arr) {
        int L = 0,R = arr.length-1;
        while(L < R) {
            for(int i = L; i < R; i++) if(arr[i] > arr[i+1]) swap(arr,i,i+1);
            R--;
            for(int i = R; i > L; i--) if(arr[i] < arr[i-1]) swap(arr,i,i-1);
            L++;
        }
    }

11.选择排序**11.**选择排序

//选择排序
    public static void selectSort(int[] arr){
        for(int i = 0; i < arr.length; i++) {
            int minIndex = i;/**记录后面的最小值的下标*/
            for (int j = i + 1; j < arr.length; j++) //注意从i+1开始
                minIndex = arr[j] < arr[minIndex] ? j : minIndex;
            swap(arr,i,minIndex);
        }
    }

好玩

《奇葩老师和小明》 老师问：什么叫摔伤？

小明回：从楼上掉下来。

老师问：什么叫幸运？

小明回：楼下有个草堆。

老师问：什么叫不幸？

小明回：草堆上有个叉子。

老师问：什么叫希望？

小明回：没掉在叉子上。

老师问：什么叫绝望？

小明回：也没掉在草堆上。

老师问：什么叫多亏了？

小明回：掉在水里。

老师问：什么叫完蛋？

小明回：水里有鲨鱼。

老师问：什么叫幸好？

小明回：猎人在旁边一枪打中了鲨鱼。

老师问：什么叫结束？

小明回：猎人射的是散弹。

老师：什么叫上天眷顾？

小明：没射中你。

老师：什么叫大难临头？

小明：你不会游泳。

老师：什么叫万幸？

小明：你在浅水区。

老师：什么叫天要亡我？

小明：水里的海草缠住了脚。

老师：什么叫必有后福？

小明：海草一挣就断。

第一阶段： 《信息学奥赛一本通》 《信息学分析讲义》

第二阶段： 《教你怎么不生气》 《佛经》 《老子》 《沉默的愤怒》

第三阶段： 《颈椎病康复指南》 《腰椎间盘突出日常护理》 《心脏病的预防与防治》 《高血压降压宝典》 《强迫症的自我恢复》 《精神病症状学》

第四阶段： 《活着》

第五阶段： 《复活》