sxr1023's Blog

如何给博客快速添加封面

sxr1023 — Wed, 29 Jul 2026 09:48:14 GMT

开始之前

博客封面，自古各大站长一大难题。

主要就两类——自己做，网上找。像洪佬他们就是自己做的，科技感满满，整齐划一，显得很正式。

具体可参考

🔗 引用站外地址，请注意甄别

博客文章封面的变迁，我是如何制作博客封面的

张洪Heo

那像我们这种懒人，用这种方法肯定是太过于浪费时间的，于是，只能选择第二种方法——网上找。

图片选择

这里推荐极简壁纸，无广告，图像质量也不错，没有水印。

🔗 引用站外地址，请注意甄别

极简壁纸 - 专注超高清壁纸无水印下载

极简壁纸

至于登录才能下载这个玩意，纯扯淡，直接 F12 找图片地址，然后下载就行。

这种办法不错，高效还能快速查找，但是总不能直接就用这个网址吧，还是说你打算用你电脑上的链接的？~~真就是“长大了我要买一台能看到别人电脑上的图片的电脑”~~

所以，要用图床。

为什么使用

网上说用 GitLab 的，我一注册账号发现好像是有免费时间限制的，吓我的放弃了。

如果你不在乎免费时间限制的话，GitLab 的确是比 Github更好的选择，尤其是在访问速度这一点。

但是，向我们这种小个体，大部分博客还是写给自己的，没必要。直接用 Github，改一下 CDN 就行了。

使用教程

太多了懒得搬教程了，我自己写也不会比这个更好，直接下面这个链接吧。

🔗 引用站外地址，请注意甄别

使用Github+picGo搭建图床，保姆级教程来了

知乎

butterfly标签外挂美化

sxr1023 — Sun, 26 Jul 2026 20:21:58 GMT

前言

美化的时候需要修改网站的源文件、添加样式、js之类的，需要一点基础，可以参考

🏠 站内链接，放心访问

Hexo博客美化前置教程

sxr1023’s Blog

常用标签外挂效果

提示

个人博客下面的效果使用频率较高，还有一个引用链接的标签外挂，放在分栏里面会有 bug，不能正常显示，可以直接看博客的实例效果。

对了，我说的常用标签外挂效果是包括这个分栏的，分栏的代码也在示例源码里面。

这是一个折叠框

Hexo博客美化前置教程

sxr1023 — Sun, 26 Jul 2026 19:06:34 GMT

前言

本站采用 Butterfly 主题，也只支持 Butterfly 主题的美化教程，没看过官方文档的建议先阅读官方文档的内容。

🔗 引用站外地址，请注意甄别

Butterfly 文档(一) 快速开始

Butterfly

高频目录

本站有部分高频文件目录地址，注意进行区分。

高频目录包括：

博客根目录 [blogRoot]
主题文件夹 [blogRoot]\themes\Butterfly
站点配置文件 [blogRoot]\_config.yml 或 _config.yml
主题配置文件 [blogRoot]\_config.butterfly.yml 或 _config.butterfly.yml

DIFF 语言

本站有时会用到 DIFF 语言，其中需要修改的部分只有前面有加号和减号的内容

...
@import '_layout/*'
@import '_tags/*'
@import '_mode/*'
+@import '_custom/*.css'
// search
-@import '_search/index'
...

例如上述代码，前面带有加号的 @import '_custom/*.css' 是你需要添加的内容，前面带有减号的 @import '_search/index' 是你需要删除的内容。

本站中的 DIFF 代码中需要添加的内容直接删掉加号就是正确的缩进。

引入自定义js和css文件

提示

本站如出现 新增xxx.css 或者 新增xxx.js 如果没有特殊说明，就是让你放在你本地的引入 css 和 js 的文件夹里，并且在主题配置文件 _config.butterfly.yml 中进行的 inject 引入。

想要魔改和美化博客，添加自定义文件是不可避免的。下面来详细说一下 css 和 js 文件的创建和引入，其他文件同理。

在博客根目录下的 source 文件夹中创建文件夹，我个人的目录如下

source/
├── static/
│       ├── css/
│       │      └── style.css
│       ├── js/
│       │      └── script.js
│       └── img/
│                └── background.png
├── _posts/
└── ...

之所以额外添加了 static 是为了方便管理，因为后续会添加很多的 page 页面，都在 source 目录下的话会显得很乱。

一般地，在主题配置文件 _config.butterfly.yml 中的 inject 引入自定义的 css 和 js 文件。

css 文件一般在 head 引入
js 文件一般在 bottom 引入（特殊情况除外）

inject:
  head:
    # 自定义css
    -  rel="stylesheet" href="/static/css/style.css?1">
    # 静态文件后面加个 ?任意内容 可以在每次更新之后让用户自动重新请求
    # 例如添加 ?1，在修改此文件后改成 ?2，用户访问时不会使用本地缓存，而是请求新的内容
    # 说人话就是有的时候要ctrl+F5才能正常显示内容，这么写不用刷新缓存也能正常显示
  bottom:
    # 自定义js
    -  src="/static/js/script.js?1">
    # 引入多个文件就直接往下复制一行改一下文件名即可，如下：
    -  src="/static/js/script1.js?1">
    -  src="/static/js/script2.js?1">
    #特殊的，可以加上类似于data-pjax的标签
    -  data-pjax src="/static/js/script3.js?1">

注意

路径最前面是斜杠 /xx/xxx.js，而不是点斜杠 ./xx/xxx.js

路径要替换成结合实际情况进行替换，不要直接照抄

特殊的，可以在 [blogRoot]\themes\Butterfly\source\css 中新建 _custom 文件夹，将 css代码直接放在 _custom 中，然后在 [blogRoot]\themes\Butterfly\source\css 中的 index.styl 写入如下代码。

if hexo-config('css_prefix')
  @import 'nib'

@import '_third-party/normalize.min.css'
// project
@import 'var'
@import '_global/*'
@import '_highlight/highlight'
@import '_page/*'
@import '_layout/*'
@import '_tags/*'
@import '_mode/*'
+@import '_custom/*'

// search
@import '_search/index'

注意

使用这种方法批量引入虽然便捷整齐，但并不方便管理，而且部分 css 代码不支持这么引入，只能采取普通的主题配置文件 inject 引入的方式，所以一般而言不推荐这种引入方式。本站中也不会采取这种方式进行引入。

全局变量参考

color.css

:root {
  --theme-color-blue: rgb(160, 205, 220);
  --theme-color-green: rgb(155, 218, 205);
  --theme-color: var(--theme-color-green);
  --theme-color2: var(--theme-color-blue);
  --scrollbar-background: #e6f4f6;
  --border-hover:#409eff;
  --border-color: rgba(0, 30, 50, 0.3);
  --nav-color: rgba(160, 205, 220, 0.75);
  --nav-color-shi: rgb(160, 205, 220);
  --text-color: #4c4948;
  --button-color: #00C4B6;
  --button-hover-color: #0F7D7F;
  --button-light-color: var(--button-color);
  --button-dark-color: var(--button-hover-color);
}
:root[data-theme="dark"] {
  --theme-color-blue: rgb(50, 80, 110);
  --theme-color-green: rgb(40, 70, 80);
  --theme-color: var(--theme-color-blue);
  --theme-color2: var(--theme-color-green);
  --scrollbar-background: #1c2833;
  --border-hover:#6699cb;
  --border-color: rgb(255, 255, 255, 0.2);
  --nav-color: rgba(50, 80, 110, 0.75);
  --nav-color-shi: rgb(50, 80, 110);
  --text-color: #FFFFFFB3;
  --button-color: #2E4964;
  --button-hover-color: #446484;
  --button-light-color: var(--button-hover-color);
  --button-dark-color: var(--button-color);
}

个人经验杂谈

善用豆包以及类似的软件，可以直接当成一个搜索引擎用
最好还是学习一下 css，当然如果你不想学的话美化着美化着也就会了
遇见 bug 可以二分，我的意思是说二分引入的 css 和 js 文件，快速定位需要修改的文件的文职
可以塞给豆包一堆 html 代码然后让他去写 css 代码，这样效率比直接让他写 css 代码高得多
豆包如果没有 “搜索XXX个关键词，参考XXX篇资料”的资料，内容有高概率是自己杜撰的，注意自己辨析
美化的时候如果插件出问题可以优先看相关的 github 的 issue，说不定有意外的收获
…

【提高组】第六课：状态压缩DP/子集枚举学习笔记

sxr1023 — Wed, 07 Feb 2024 08:17:46 GMT

第六课：状态压缩DP/子集枚举

🔗 引用站外地址，请注意甄别

第六课：状态压缩DP/子集枚举

517coding

与：同为 1 ，则为 1，否则为0。即只要有一位是 0，结果就是0
或：同为 0 ，则为 0，否则为1。即只要有一位是 1，结果就是1
异或：不同则为 1，相同则为 0

已知一个状态压缩的数 $i$，有如下操作：

求 $i$ 的第 $j$ 位是否为 $1$ ：i&(1< （注意：是 !=0，而不是==1）
把 $i$ 的第 $j$ 位修改为 $1$：i|=1<

`A：环游世界`

    🔗 引用站外地址，请注意甄别
            
                    环游世界
            517coding
        
            
    首先，这很明显是一个无向图
这样，我们需要的信息就是：
已走过的点集
当前停留在哪里
当前的最小花费
知道了这三个信息之后，转移时只要枚举一个未走过的点，从当前的位置转移过去，再把花费加上即可
在做最短路是通常不会主动去构造一个环，而本题要求从起点出发，再回到起点
我们可以先找到一个点 $T$ ，求出起点到 $T$ 的最短路，最后再单独加上 $T$到起点的距离
表示已走过的集合就可以用状态压缩
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include 
#include 
#define min(a, b) (a

//mp[i][j]表示i到j的距离
int mp[12][12];

//dp[i][j]表示经过了i状态的点集，当前停留在j的最小代价
int dp[1 << 12][12];

int n;
void checkmin(int &x, int y) {x == -1 || y < x ? x = y: x = x;}
void input() {
  scanf("%d", &n);
  n++;
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++)
      scanf("%d", &mp[i][j]);
}
void floyd() {
  for (int k = 0; k < n; k++)
    for (int i = 0; i < n; i++)
      for (int j = 0; j < n; j++)
        mp[i][j] = min(mp[i][j], mp[i][k] + mp[k][j]);
}
void change() {
  memset(dp, 0x3f, sizeof(dp));
  dp[1][0] = 0;
  //枚举已有的状态去转移给未知的状态
  for (int mask = 1; mask < (1 << n); mask++) {
    //枚举了一个已经求好的状态dp[mask][end]
    for (int end = 0; end < n; end++) if (dp[mask][end] != 0x3f3f3f3f) {
      //枚举一个未走过的点
      for (int nxt = 0; nxt < n; nxt++) if (!(mask & (1 << nxt))) {
        checkmin(dp[mask | (1 << nxt)][nxt], dp[mask][end] + mp[end][nxt]);
      }
    }
  }
}
void print() {
  int ans = 0x3f3f3f3f;
  for (int end = 0; end < n; end++) {
    checkmin(ans, dp[(1 << n) - 1][end] + mp[end][0]);
  }
  printf("%d\n", ans);
}
int main() {
  input();//输入
  floyd();//floyd求最短路
  change();//状态转移
  print();//计算答案
  return 0;
}
B：数字重排
    🔗 引用站外地址，请注意甄别
            
                    数字重拍
            517coding
        
            
    观察到 $n$ 最大只有 $16$
那么就可以使用状态压缩
共有两个信息：数字、位置
暴力
$dp_{i_j}$ 中 $i$ 表示放了那哪些位置，$j$ 表示放了哪些数字
接着枚举一个空的位置，进行转移
但是这样的话就要开大小为 $2^{16}\times2^{16}$ 个数组，也就是 $2^{32}$ 个
状态压缩
$dp_{ij}$ 中 $i$ 表示放了数字的集合，$j$ 表示以谁结尾
这时候位置就不重要了，因为当我们可以直接从左往右依次放进去，只需要考虑结尾即可，不用管位置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include 
#include 

const int N = 18;
const int INF = (int) 1e9;

int a[N], p[N], b[N];
int dp[1 << N][N];
void checkmax(int &x, int y) {if (y > x) x = y;}
int main() {
  int n; scanf("%d", &n);
  memset(b, -1, sizeof(b));
  for (int i = 0; i < n; i++) {scanf("%d%d", &a[i], &p[i]); if (p[i] != -1) b[p[i]] = 1;}
  for (int i = 0; i < (1 << n); i++) for (int j = 0; j < n; j++) dp[i][j] = -INF;
  //设置初始状态，放第一个数
  if (b[0]) for (int i = 0; i < n; i++) if (p[i] == 0) dp[1 << i][i] = 0;
  else for (int i = 0; i < n; i++) if (p[i] == -1) dp[1 << i][i] = 0;
  for (int mask = 0; mask < (1 << n); mask++) {
    int pos = 0;//记录mask状态有几个1
    for (int i = 0; i < n; i++) if (mask & (1 << i)) pos++;
    for (int end = 0; end < n; end++) if (dp[mask][end] != -INF)
      //下一个数放a[nxt]
      for (int nxt = 0; nxt < n; nxt++) if (!(mask & (1 << nxt)))
        //下面的逻辑：如果a[nxt]还没有放过，而且它可以放在pos位置
        //是否可以放在pos位置
        //1. a[nxt]呗钦点在pos位置
        //2. a[nxt]可以随便放
        if (p[nxt] == -1 || p[nxt] == pos) checkmax(dp[mask | (1 << nxt)][nxt], dp[mask][end] + a[end] * a[nxt]);
  }
  int ans = -INF;
  for (int end = 0; end < n; end++) checkmax(ans, dp[(1 << n) - 1][end]);
  printf("%d\n", ans);
  return 0;
}
C：开门迷宫
    🔗 引用站外地址，请注意甄别
            
                    开门迷宫
            517coding
        
            
    广搜 + 状压DP即可
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include 
#include 
#include 
using namespace std;

const int N = 60;

int n,m,p,k,s;
int x1,y1,x2,y2,x;
int mp1[N][N][N][N], mp2[N][N],vis[N][N][1<<11];

int dx[]= {0,0,1,-1};
int dy[]= {1,-1,0,0};

struct node {
  int x,y,key,step;
};

queueq;
int bfs() {
  q.push({0,0,0,0});
  vis[0][0][0] = 1;
  while(!q.empty()) {
    node f = q.front(); q.pop();
    if(f.x == n - 1 && f.y == m - 1) return f.step;
    if(mp2[f.x][f.y] >= 1) f.key += mp2[f.x][f.y] - (mp2[f.x][f.y] & f.key);
    for (int i = 0; i < 4; i++) {
      int ax = f.x + dx[i];
      int ay = f.y + dy[i];
      if(ax >= 0 && ax < n && ay >= 0 && ay < m) {
        int tmp = mp1[f.x][f.y][ax][ay];
        if(tmp == -1 || (tmp>= 1 && (f.key & (1 << tmp)))) {
          if(!vis[ax][ay][f.key]) {
            q.push({ax,ay,f.key,f.step+1});
            vis[ax][ay][f.key]=1;
          }
        }
      }
    }
  }
  return -1;
}
int main() {
  scanf("%d%d%d%d", &n, &m, &p, &k);
  memset(mp1, -1, sizeof(mp1));
  memset(mp2, 0, sizeof(mp2));
  for (int i = 1; i <= k; i++){
    scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &x);
    mp1[x1 - 1][y1 - 1][x2 - 1][y2 - 1] = mp1[x2 - 1][y2 - 1][x1 - 1][y1 - 1]=x;
  }
  scanf("%d", &s);
  for (int i = 1; i <= s; i++) {
    scanf("%d%d%d", &x1, &y1, &x);
    if(x != 0) mp2[x1 - 1][y1  - 1] += 1 << x;
  }
  int ans = bfs();
  printf("%d\n", ans);
  return 0;
}
E：回文子序列删除
    🔗 引用站外地址，请注意甄别
            
                    回文子序列删除
            517coding
        
            
    $1$ 个状态可以由多个状态转移过来，那么可以可以转移过来的状态构成了一个子集
$dp_i$ 表示 $i$ 状态的字符集合最少需要删几次
枚举这个状态的回文子集，然后扔掉
假设枚举的回文子集为 $s$ ，那么 $dpi$ 就可以由 $dp{i-s}+1$ 在转移过来
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include 
#include 
#include 
#include 

const int N = 18;
const int INF = (int) 1e9;

char s[N];
int dp[1 << N], flag[1 << N], n;

std::vector<int> v;
//判断mask状态的字符是否是回文的
bool judge(int mask) {
  v.clear();
for (int i = 0; i < n; i++) if (mask & (1 << i)) v.push_back(i);
int l = 0, r = (int) v.size() - 1;
while (l <= r) {
if (s[v[l]] != s[v[r]]) return false;
l++, r--;
}
return true;
}
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 1; i < (1 << n); i++) {
if(judge(i)) dp[i] = 1, flag[i] = 1;
else dp[i] = INF;
}
for (int mask = 0; mask < (1 << n); mask++)
    //枚举子集
    for (int sub = mask; sub > 0; sub = mask & (sub - 1)) if (flag[sub]) dp[mask] = std::min(dp[mask], dp[mask - sub] + 1);
  printf("%d\n", dp[(1 << n) - 1]);
  return 0;
}



P10112 [GESP202312 八级] 奖品分配 题解
sxr1023 — Mon, 05 Feb 2024 11:10:28 GMT
    🔗 引用站外地址，请注意甄别
            
                    P10112 [GESP202312 八级] 奖品分配
            洛谷
        
            
    这道题目总的来说代码量不多，但是思维很麻烦。
题目说，所有的奖品加起来正好等于 $n$ 或等于 $n+1$。
那么，就可以进行分类讨论。
第一种情况：奖品数正好等于 $n$。
这种情况下就是说每个同学正好只拿一个奖品。
假设有 $10$ 名同学，奖品有 $3$ 种，每种奖品的个数分别为 $3,2,5$。
首先，我们要从 $10$ 个人中选择 $5$ 个人拿第三种奖品，那么组合情况数 $C_{10}^{5}$。
接下来，从剩下的 $5$ 个人中选择 $2$ 个人拿第二种奖品，那么组合情况数为 $C_{5}^{2}$。
那么最后只剩下 $3$ 个人，只能拿第一种奖品，即组合情况数位 $C_{3}^{3}$。
这样的选取方法结果就是 $C{10}^{5}\times C{5}^{2}\times C_{3}^{3}=2520$。
如果换一种顺序取选取奖品，假如说从前往后取，先取第一种奖品，再取第二种奖品，最后取第三种奖品，结果就是 $C{10}^{3}\times C{7}^{2}\times C_{5}^{5}=2520$。
两个式子的结果相等的，这就证明了这种计算方法的正确性。
这种情况下的公式为 $C{n}^{a_1}\times C{n-a1}^{a_2}\times C{n-a1-a_2}^{a_3}\times…\times C{n-a1-a_2-…-a{n-1}}^{a_n}$ 。
第二种情况：奖品数等于 $n+1$。
如果奖品数等于 $n+1$ 的话，最终就会多出来一个奖品。
仍然举一个例子：有 $10$ 名同学，$3$ 种奖品，每种奖品的数量分别是 $4,5,2$。
第一种思路：我们可以假设多出的奖品分别是第几种奖品。
假设多出的是第一种奖品，那就减掉好了，奖品数就变成了 $3,5,2$。
假设多出的是第二种奖品，奖品数就变成了 $4,4,2$。
假设多出的是第三种奖品，奖品数就变成了 $4,5,1$。
一共就得到了三种情况，分别按照第一种情况算即可。
分别相加，得到结果为 $C{10}^{3}\times C{7}^{5}\times C{2}^{2}+C{10}^{4}\times C{6}^{4}\times C{2}^{2}+C{10}^{4}\times C{6}^{5}\times C_{1}^{1}=6930$。
但是这样做的复杂度是多少呢？毫无疑问，是 $O(MT)$，很明显会超时。
第二种思路：不是去掉物品，而是多加一个人。因为多出的奖品即使不给人也要放在那里，因此可以假设多出来一个人，多出的一个奖品正好给多出的一个人。这样就转换成了第一种情况。
最终结果为 $C{11}^{4}\times C{7}^{5}\times C_{2}^{2}=6930$。
第一种思路的结果和第二种思路的结果正好相等，说明了第二种思路的正确性。
因为只是让同学数加一，所以复杂度和第一种情况相等，完全可以通过。
这种情况下的公式为 $C{n+1}^{a_1}\times C{(n+1)-a1}^{a_2}\times C{(n+1)-a1-a_2}^{a_3}\times…\times C{(n+1)-a1-a_2-…-a{n-1}}^{a_n}$ 。
题目中说，所有奖品的数量不是等于 $n$ 就是等于 $n+1$，简单整理以下，设 $sum$ 为所有奖品的总数量，最终的答案就是  $C{sum}^{a_1}\times C{sum-a1}^{a_2}\times C{sum-a1-a_2}^{a_3}\times…\times C{sum-a1-a_2-…-a{n-1}}^{a_n}$ 。
至于组合数可以使用杨辉三角预处理。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include 
using namespace std;

const int N = 1010;
const int mod = 1e9 + 7;

int a[N], C[N][N];

//利用杨辉三角预处理组合数
void init() {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j <= i; j++) {
            if (j == 0 || j == i) C[i][j] = 1;
            //边加边取模
            else C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
        }
    }
}
int main() {
    init();
    int T;
    scanf("%d", &T);
    while(T--) {
        int n, m;
        scanf("%d%d", &n, &m);
        int sum = 0;
        for (int i = 1; i <= m; i++) {
            scanf("%d", &a[i]);
            sum += a[i];
        }
        long long ans = 1;//注意开long long
        for (int i = 1; i <= m; i++) {
            //这里的结果计算方法参考上面的讲解
            //直接用sum来计算答案省的考虑两种情况
            ans = (ans * C[sum][a[i]]) % mod;
            sum -= a[i];
        }
        printf("%lld\n", ans);
    }
    return 0;
}



P10109 [GESP202312 六级] 工作沟通 题解
sxr1023 — Mon, 05 Feb 2024 11:10:18 GMT
    🔗 引用站外地址，请注意甄别
            
                    P10109 [GESP202312 六级] 工作沟通
            洛谷
        
            
    每次询问输出多个点的编号最大的公共祖先，本质上就是 LCA 问题。  
这里提供一种思路：把每个点的祖先全部求出来，然后用数组标记，如果这个点被标记了 $m$ 次，那就说明这个点是所有员工的公共祖先。  
最后输出最大值即可。  
因为这道题的数据比较小，所以这样做的时间复杂度是完全可行的。  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include 
using namespace std;

const int N = 100010;
int fa[N], vis[N];

void change(int x) {
    vis[x]++;//自己能管理自己，即自己是自己的祖先
    while(x != 0) {
        x = fa[x];//一直向上找祖先
        vis[x]++;//记录这个点作为祖先的个数
    }
}
int main() {
    int n;
    scanf("%d", &n);
    for (int i = 1; i < n; i++) {
        scanf("%d", &fa[i]);
    }
    int q;
    scanf("%d", &q);
    while(q--) {
        int m;
        scanf("%d", &m);
        //注意vis数组要清空
        memset(vis, 0, sizeof(vis));
        for (int i = 1; i <= m; i++) {
            int x;
            scanf("%d", &x);
            change(x);//每输入一个数，进行标记
        }
        int ans = 0;
        //因为是从小到大枚举的，所以不用取max
        for (int i = 1; i < n; i++) {
            if (vis[i] == m) ans = i;
        }
        printf("%d\n", ans);
    }
    return 0;
}



【提高组】第五课：动规 学习笔记
sxr1023 — Sun, 04 Feb 2024 18:46:34 GMT
第五课：动规
    🔗 引用站外地址，请注意甄别
            
                    第五课：动规
            517coding
        
            
    A：最少末尾零
    🔗 引用站外地址，请注意甄别
            
                    最少末尾零
            517coding
        
            
    记录 $2$ 最少的路径的 $2$ 的个数和 $5$ 最少的路径的 $5$ 的个数，最后取较小值即可
注意特判数组中有 $0$ 的情况
$dp_{ij0}$ 表示走到 $i$ 行 $j$ 列 $2$ 的最少个数
$dp_{ij1}$ 表示走到 $i$ 行 $j$ 列 $5$ 的最少个数
状态转的时候可以先转移第一行和第一列，这样减少思考
然后其余的状态由上面和左面转移即可
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include
using namespace std;

const int N = 1010;

int dp[N][N][2];
int lst[N][N][2];

int flag = -1,n,x;
int mp[N][N][2];

char s[N*5];
int tot;
int main() {
    scanf("%d",&n);
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= n; j++) {
            scanf("%d", &x);
            if(x != 0) {
                while(x % 2 == 0) x /= 2,mp[i][j][0]++;
                while(x % 5 == 0) x /= 5,mp[i][j][1]++;
            }
            else flag = i,mp[i][j][0] = mp[i][j][1] = 1000;
        }
    }
    for(int op = 0; op < 2; op++) {
        dp[1][1][op] = mp[1][1][op];
        for(int i = 2; i <= n; i++) {
            lst[1][i][op] = 1;lst[i][1][op] = -1;
            dp[1][i][op] = dp[1][i-1][op] + mp[1][i][op];
            dp[i][1][op] = dp[i-1][1][op] + mp[i][1][op];
        }
        for(int i = 2; i <= n; i++) {
            for(int j = 2; j <= n; j++) {
                if(dp[i][j-1][op] < dp[i-1][j][op]) lst[i][j][op] = 1, dp[i][j][op] = dp[i][j - 1][op] + mp[i][j][op];
                else lst[i][j][op] = -1, dp[i][j][op] = dp[i - 1][j][op] + mp[i][j][op];
            }
        }
    }
    if(flag != -1 && min(dp[n][n][0],dp[n][n][1])) {
        printf("1\n");
        for(int i = 2; i <= flag; i++) printf("D");
        for(int j = 2; j <= n; j++) printf("R");
        for(int i = flag + 1; i <= n; i++) printf("D");
        return 0;
    }
    int ans;
    if(dp[n][n][0] < dp[n][n][1]) ans = 0;
    else ans = 1;
    printf("%d\n",min(dp[n][n][0],dp[n][n][1]));
    int nowx = n, nowy = n;
    while(true) {
        if(lst[nowx][nowy][ans] == 1) nowy--, s[++tot] = 'R';
        else nowx--, s[++tot] = 'D';
        if(nowx == 1 && nowy == 1) break;
    }
    for(int i = tot;i >= 1;i--) putchar(s[i]);
    return 0;
}
B：凑硬币
    🔗 引用站外地址，请注意甄别
            
                    凑硬币
            517coding
        
            
    中级班原题，多重背包问题
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include 
using namespace std;

const int N = 100010;

int f[N], v[N];
int a[N], s[N];
int main() {
int n, m;
scanf("%d%d", &n, &m);
int sum = 0, tot = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &s[i]);
int t = 1;
while(s[i] >= t) {
v[++tot] = a[i] * t;
s[i] -= t;
t *= 2;
}
v[++tot] = a[i] * s[i];
}
f[0] = 1;
for (int i = 1; i <= tot; i++) {
for (int j = m; j >= 1; j--) {
if (f[j - v[i]] == 1) f[j] = 1;
}
}
for (int i = 1; i <= m; i++) {
if (f[i] == 1) sum++;
}
printf("%d\n", sum);
return 0;
}



【提高组】第四课：三分/01分数规划 学习笔记
sxr1023 — Sun, 28 Jan 2024 14:18:45 GMT
三分/01分数规划
    🔗 引用站外地址，请注意甄别
            
                    第四课：三分/01分数规划
            517coding
        
            
    A：点到线段的距离
    🔗 引用站外地址，请注意甄别
            
                    点到线段的距离
            517coding
        
            
    三分
通过观察可以发现，点 $P$ 到线段 $AB$ 的距离呈 “U” 字形
接下来只用再这个 “U” 字形种寻找最小的点即可
首先设最左边的端点为 $l$ ，最右边的端点为 $r$ 
第一次滑动到三分之一和三分之二位置，设三分之一位置为 $mid1$ ，三分之二位置为 $mid2$  
假如 $mid1
相反，如果 $mid2
要使得答案始终都在 $mid1$ 和 $mid2$ 之间，这样等到它们足够接近时，就可以找到答案
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include 
using namespace std;

const double eps = 1e-8;

struct point {
    double x, y, z;
};

point A, B, P;

//计算三维坐标中两点的距离
double dis(point a, point b) {
    double tmp1 = b.x - a.x;
    double tmp2 = b.y - a.y;
    double tmp3 = b.z - a.z;
    return sqrt(tmp1 * tmp1 + tmp2 * tmp2 + tmp3 * tmp3);
}
//根据比例算出P点到s点的距离
double get(double mid) {
    point s;
    s.x = A.x + (B.x - A.x) * mid;
    s.y = A.y + (B.y - A.y) * mid;
    s.z = A.z + (B.z - A.z) * mid;
    return dis(s, P);
}
int main() {
    int T;
    cin >> T;
    while(T--) {
        cin >> A.x >> A.y >> A.z;
        cin >> B.x >> B.y >> B.z;
        cin >> P.x >> P.y >> P.z;
        //三分AS：SB的比值
        double l = 0, r = 1, best = -1;
        while(fabs(r - l) > eps) {
            double mid1 = l + (r - l) / 3;
            double mid2 = r - (r - l) / 3;
            best = get(mid1);//记录答案
            if (get(mid1) - get(mid2) < -eps) r = mid2;
            else l = mid1;
        }
        printf("%.2f\n", best);
    }
    return 0;
}
B：三角形与四边形
    🔗 引用站外地址，请注意甄别
            
                    三角形与四边形
            517coding
        
            
    算法：浮点二分
假设 AD 的长度为 $x$ ，那么 $DB$ 的长度为 $AB-x$，那么就可以得到三角形和四边形的面积比
紧接着，我们发现 $x$ 越大，三角形和四边形的比值也会越大，这样就发现这道题题目具备单调性，可以二分
因为比值涉及浮点数，所以要用浮点二分
值得注意的是二分的上界，经过计算， $x$ 最终的结果不会超过 $AB$ （因为 $x$ 是从 $AB$ 上截取的线段）
关于三角形已知三条边求面积
可以直接用公式
先算出周长的一半 $p = (a+b+c)/2$，其中 $a,b,c$ 分别为三角形的三条边
然后面积 $S = \sqrt{p(p-a)(p-b)(p-c)}$
也可以直接输出AB/sqrt((k+1)/k)
注意 eps 的精度！
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include 
using namespace std;

const double eps = 1e-10;
double ab, ac, bc, k;

//已知三角形三条边求面积
double calc(double a, double b, double c) {
    double p = (a + b + c) / 2;
    return sqrt(p * (p - a) * (p - b) * (p - c));
}
bool check(double x) {
    double ad = x;
    double ae = ac * ad / ab;
    double de = ad * bc / ab;
    double ans = calc(ad, ae, de) / (calc(ab, ac, bc) - calc(ad, ae, de));
    return ans - k > -eps;
}
int main() {
    int T, ca = 1;
    scanf("%d", &T);
    while(T--) {
        scanf("%lf%lf%lf%lf", &ab, &ac, &bc, &k);
        double l = 0, r = ab, best = -1;
        while(fabs(r - l) > eps) {
            double mid = (l + r) / 2;
            //check(mid)如果返回true表示AD=mid的时候面积比>=k
            if (check(mid)) best = mid, r = mid;//注意这里l,r不用+1或-1
            else l = mid;
        }
        printf("Case %d: %.2f\n", ca++, best);
    }
    return 0;
}
C：最大比例
    🔗 引用站外地址，请注意甄别
            
                    最大比例
            517coding
        
            
    转化
注意：以下的 $v_1,v_2,v_3…v_k$ 和 $w_1,w_2,w_3+…w_k$ 都代表的是从原数组中任意的 $k$ 个数
解： $\frac{v_1+v_2+v_3+…+v_k}{w_1+w_2+w_3+…+w_k}=ans$
两边同时乘上 $w_i+w_2+w_3+…w_k$ ，得
$v_1+v_2+v_3+…+v_k=ans(w_1+w_2+w_3+…w_k)$
把 $ans$ 乘进 $(w_1+w_2+w_3+…w_l)$，得
$v_1+v_2+v_3+…v_k=ans·w_1+ans·w_2+ans·w_3+…+ans·w_k$
移项，得
$(v1-ans·w_1)+(v_2-ans·w_2)+(v_3-ans·w_3)+…+(v_k-ans·w_k)=0$
其中 $ans$ 相当于选出 $k$ 个数的比例
设 $a_i=v_i-ans·w_i$ 
就可以设出一个平直角坐标系的纵坐标（ $y$ 轴）为最大的 $k$ 个 $a_i$ 的和（即前 $k$ 大的 $a_i$ 的和）
单调性
当 $ans$ （比例）越大的时候，前 $k$ 大的数会越小
需要求的就是 $ans$ 尽量的大，但同时使得 $a_1+a_2+a_3+…+a_k$ 大于等于 $0$ 
知道了单调性以后，二分比值即可，然后去找 $a_i$ 中较大的 $k$ 个 $0$ 进行 check
当 $ans$ 最大的时候，$a_1+a_2+a_3+…+a_k=0$，这就是最终的答案
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include 
using namespace std;
 
const int N = 100010;
const double INF = 1000010;
const double eps = 1e-8;

int n, k;
struct node {
    int id;
    int v, w;
    double x;
    //计算式子中的每一个“a[i]”
    void calc(double tmp) {
        x = v - tmp * w;
    }
    //重载运算符
    bool operator < (const node& cmp) const {
        return x > cmp.x;
    }
} a[N];
 
//判断式子是否大于等于0
bool check(double x) {
    for (int i = 1; i <= n; i++) a[i].calc(x);
    sort(a + 1, a + n + 1);
    double tmp = 0;
    for (int i = 1; i <= k; i++) tmp += a[i].x;
    return tmp >= 0;
}
 
int main() {
    scanf("%d%d", &n, &k);
    for (int i = 1; i <= n; i++) {
        scanf("%d%d", &a[i].v, &a[i].w);
        a[i].id = i;//记录编号，防止排序影响结果
    }
    //二分比值
    double l = 0, r = INF;
    while(fabs(r - l) > eps) {
        double mid = (l + r) / 2;
        if (check(mid)) l = mid;
        else r = mid;
    }
    for (int i = 1; i <= k; i++) {
        printf("%d ", a[i].id);
    }
    return 0;
}
D：后缀零
    🔗 引用站外地址，请注意甄别
            
                    后缀零
            517coding
        
            
    算法：整数二分
题意：找到一个最小的 $n$ ，使得 $n!$ 末尾一共有 $Q$ 个 $0$ （$Q \le 10^8$）
怎样求 $n!$ 末尾有多少个0
$n!$ 末尾有几个 $0$ ，要怎么算呢？
举个栗子，比如说 $25!$
$25!=1\times2\times3\times4\times5\times……\times23\times24\times25$
末尾的 $0$ 是怎么得到的呢？
是 $5$ 的个数，因为 $2\times5=10$ ，能够产生一个 $0$，其他的所有的末尾的 $0$ 都是这么得来的
一个数的阶乘末尾的 $0$ 怎么得来的呢？
其实就是阶乘中相乘的数包含的 $5$ 的个数
$25!$ 中包含 $5$ 的数有 $5,10,15,20,25$ 
其中包含一个 $5$ 的数有 $5,10,15,20$
包含两个 $5$ 的数有 $25$
总结以下这道题目的方法：求 $n!$ 末尾有几个 $0$ 本质上就是求 $\frac{n}{5}+\frac{n}{5^2}+……\frac{n}{5^k}$ ，一直到加的数小于 $1$ 为止
单调性
一个数的阶乘末尾的 $0$ 的个数是具备单调性的，这个数越大，末尾的 $0$ 越多，所以可以二分
二分的上界
二分很重要的依据就是二分的上界，那么这道题目二分的上界应该是多少呢？
$Q$ 大概有 $10^8$，所以我们需要知道多少的阶乘末尾有 $10^8$ 个 $0$ 
1
2
3
4
5
6
7
8
int get(int n) {
    int ans = 0;
    while(n > 0) {
        ans += n / 5;
        n /= 5;
    }
    return ans;
}
get 函数用来获取一个数的阶乘末尾 $0$ 的个数，如果输出 get (1e9)，输出的结果很明显大于 $10^8$，所以可以得到二分的上界应当为 $10^9$  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include 
using namespace std;

const int INF = (int) 1e9;//二分上界

//求n！末尾有几个0，效率为O(logn)
int get(int n) {
    int ans = 0;
    while(n > 0) {
        ans += n / 5;
        n /= 5;
    }
    return ans;
}
int main() {
    int T, ca = 1;
    scanf("%d", &T);
    while(T--) {
        int Q;
        scanf("%d", &Q);
        printf("Case %d: ", ca++);
        int l = 1, r = INF, best = -1;
        //找到阶乘结尾大于等于Q个0的最小的数
        while(l <= r) {
            int mid = (l + r) / 2;
            if (get(mid) >= Q) best = mid, r = mid  - 1;
            else l = mid + 1;
        }
        //需要验证是不是刚好Q个0
        if (get(best) == Q) printf("%d\n", best);
        else printf("impossible\n");
    }
    return 0;
}
（srds，这道题初级班也出现过
E ：最小距离最大化
    🔗 引用站外地址，请注意甄别
            
                    最小距离最大化
            517coding
        
            
    题意：在坐标轴上有 n 个点，从中选取 m 个点，使得这m个点两两之间的最小距离最大。
一眼二分
二分，然后 check 一下即可
值得注意的是，记得给原数组排序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include 
using namespace std;

const int N = 100010;
const int INF = (int) 1e9;

int a[N];

int n, m;
bool check(int x) {
    int cnt = 1;
    int lst = 1;
    for (int i = 2; i <= n; i++) {
        if (a[i] - a[lst] >= x) {
            cnt++;
            lst = i;
            if (cnt == m) break;
        }
    }
    return cnt >= m;
}
int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
    }
    sort(a + 1, a + n + 1);
    int l = 0, r = INF, best = -1;
    while(l <= r) {
        int mid = (l + r) / 2;
        if (check(mid)) l = mid + 1, best = mid;
        else r = mid - 1;
    }
    printf("%d\n", best);
    return 0;
}
F：矩阵
    🔗 引用站外地址，请注意甄别
            
                    矩阵
            517coding
        
            
    题意：
有一个 $N\times N$ 的矩阵。
第 $i$ 行第 $j$ 列的值为 $i^2+100000\times i+j^2-100000\times j+i\times j$
求矩阵中第 $M$ 小的数。
解法
写个函数方便测试：
1
2
3
long long f(int x,int y){
return 1ll * x * x + 100000ll * x + 1ll * y * y - 100000ll * y + 1ll * x * y;
}
从 $f(1,1)$ 已知输出到 $f(5,5)$ ，结果如下：
1
2
3
4
5
3 -99993 -199987 -299979 -399969
100007 12 -99981 -199972 -299961
200013 100019 27 -99963 -199951
300021 200028 100037 48 -99939
400031 300039 200049 100061 75
观察到在列数不变的情况下，每一行的大小是递增的
这样我们就可以先二分答案，再枚举每一行，最后二分答案
（简单来说就是一个二分套二分
不开long long见祖宗
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include
using namespace std;

long long f(int x,int y){
return 1ll * x * x + 100000ll * x + 1ll * y * y - 100000ll * y + 1ll * x * y;
}
int T, N;
long long M;
long long check(long long x) {
long long ret = 0;
for(int j = 1; j <= N; j++){
int l = 1,r = N,  ans = 0;
while(l <= r) {
long long mid = (l + r) / 2;
if(f(mid,j) <= x) {
ans = mid;
l = mid + 1;
}
else r = mid - 1;
}
ret += ans;
}
return ret;
}
int main() {
scanf("%d",&T);
while(T--){
scanf("%d%lld", &N, &M);
long long l = -1e12;
long long r = 1e12;
long long ans;
while(l <= r){
long long mid = (l + r) / 2;
long long tmp = check(mid);
if(tmp >= M) {
ans = mid;
r = mid - 1;
}
else l = mid + 1;
}
printf("%lld\n",ans);
}
return 0;
}



【提高组】第三课：STL 学习笔记
sxr1023 — Fri, 26 Jan 2024 16:38:13 GMT
不用自定义hr的内容和.custom_hr的内容，只要将hr的内容等同于.custom_hr的内容即可（后者替换前者也行）
STL
    🔗 引用站外地址，请注意甄别
            
                    第三课：STL
            517coding
        
            
    A：水果店
    🔗 引用站外地址，请注意甄别
            
                    水果店
            517coding
        
            
    考察 map 的使用
map 可以将一个数据类型映射到另一个数据类型
map 的定义
1
2
3
4
5
6
7
8
9
10
11
12
#include 
using namespace std;

int main() {
    map<int, int> mp;
    mp[10] = 5;
    mp[20] = 1;
    mp[15] = 2;
    mp[1000000000] = 4;
    cout << mp.size() << endl;
    return 0;
}
以上代码会输出 $3$
map 的遍历
迭代器
因为 map 是一种容器，所以只能用迭代器进行访问
1
2
3
for (map<int, int>::iterator it = mp.begin(); it != mp.end(); it++) {
    cout << it->first << " " << it->second << endl;
}
这样可以对 map 进行排序
如果你利用这份代码进行输出的话，你会发现：输出的结果会自动排序，先按第一维关键字（it->first）进行从小到大，再按第二维关键字（it->second）从小到大进行排序
auto 进行遍历
我们发现刚刚的代码太长了，有没有什么办法可以让代码变短一点呢？
答案是有的（建议充分理解上面的方法后再使用以下方法）
使用 C++11 的 auto
1
2
3
for (auto it : mp) {
    cout << it.first << " " << it.second;
}
值得注意的是，如果使用迭代器，输出就是 it->first 和 it->second
如果使用 auto，输出就是 it.first 和 it.second
map 的用法
map mp 定义
mp[10]=100 映射
mp.find(10) 查找（第一关键字） ,找到返回得迭代器，找不到返回 mp.end
map 可以很方便的进行计数，统计，因为它是一个容器，第一关键字和第二关键字是不需要管大小的
但是它的效率不是 $O(1)$ 的，而是 $O(logn)$ 
本题的朴素版写法（迭代器）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include 
using namespace std;

//map 是可以叠加定义的，但是要注意中间的空格，低版本的编译器可能会报错
mapint> >mp;
int main() {
    int n;
    scanf("%d", &n);
    string shuiguo, city;
    int xiaoliang;
    for(int i = 0; i < n; i++) {
        cin >> shuiguo >> city >> xiaoliang;
        mp[city][shuiguo] += xiaoliang;
    }
    mapint> >::iterator it1;
    mapint>::iterator it2;
    //遍历整个容器
    //先遍历外面map >
    for(it1 = mp.begin(); it1 != mp.end(); it1++) {
        cout << it1->first << endl;
        //再遍历里面的map
        for(it2 = it1->second.begin(); it2 != it1->second.end(); it2++)
        {
            cout << "   |----" << it2->first << "(" << it2->second << ")" << endl;
        }
    }
    return 0;
}
因为这样写代码量太多了，所以就有了更简短的方法
本题的高端写法（auto）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include 
using namespace std;

mapint> > mp;
int main() {
    int n;
    scanf("%d", &n);
    string shuiguo, city;
    int xiaoliang;
    for(int i = 0; i < n; i++) {
        cin >> shuiguo >> city >> xiaoliang;
        mp[city][shuiguo] += xiaoliang;
    }
    //auto直接在for循环里面用 ":" 遍历
    for (auto it1 : mp) {
        cout << it1.first << endl;
        for (auto it2 : it1.second) {
            cout << "   |----" << it2.first << "(" << it2.second << ")" << endl;
        }
    }
    return 0;
}
Set
    🔗 引用站外地址，请注意甄别
            
                    Set
            517coding
        
            
    set 的用法
注意：set是集合，自动去重
基本用法
set st 定义
st.insert(x) 插入 $x$ （默认从小到大排序）
遍历：
1
2
3
for (set<int>::iterator it = st.begin(); it != st.end(); it++) {
    cout << *it << endl;
}
或者
1
2
3
for (auto it : st) {
    cout << it << endl;
}
最值、删除和查找
最小值为 *st.begin() 
最大值为 *(--st.end()) 或 *(st.rbegin()) 
要注意的是：迭代器只能 ++ 或 - - ，如果换成 +1 或 -1 就会报错
删除有两种方式
st.erase(10)
st.erase(it)
也就是说 st.erase() 函数的参数既可以是一个数值，也可以是一个迭代器
但是如果删除一个并不存在的数值或者迭代器，就会出现一些奇奇怪怪的 bug，因此，在执行删除操作之前，一般要查找这个元素是否存在
st.find(10) 查找，找到返回迭代器，否则返回 st.end()
lower_bound 和 upper_bound
st.lower_bound(10) 返回大于等于 $10$ 的第一个迭代器位置，如果没有返回 st.end()
st.upper_bound(10) 返回第一个严格大于 $10$ 的迭代器位置，如果没有分会 st.end()
利用这两个函数，可以衍生出其他的技巧
最后一个小于：找出第一个大于等于，再往前跳一个
1
2
3
4
5
auto it = st.lower_bound(20);
if (it != st.begin()) {
    it--;
    cout << *it << endl;
}
求最后一个不大于（超过）：求出第一个严格大于，再往前跳一个
1
2
3
4
5
auto it = st.upper_bound(20);
if (it != st.begin()) {
    it--;
    cout << *it << endl;
}
注意：凡是涉及到向前跳一个的，都要判断等不等于 begin
multiset 和 set 的区别
首先 multiset 是可重复集合，而 set 是不可重复集合
其次，multiset 如果是删除一个数值，那么会把所有等于这个数的全部删除，如果删除的是一个迭代器，那么只会删除这个位置
巧记 begin 和 end
计算机左闭上右开，所以 --end() 才有数值
所有操作不成立全部返回 end ，唯独向前跳一个是例外
特殊记忆小于某个数的最大的和不大于（超过）某个数最大的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include 
using namespace std;

multiset<int> st;
int main() {
    int n;
    scanf("%d", &n);
    while(n--) {
        string op;
        int x;
        cin >> op;
        scanf("%d", &x);
        if (op == "Push") st.insert(x);
        else {
            //这里也可以写成multiset::iterator it = st.upper_bound(x);
            auto it = st.upper_bound(x);
            //注意这里是判断等不等于st.begin()
            if (it == st.begin()) printf("No Element!\n");
            else {
                //it在这里再--，在上面的话可能会出错
                it--;
                printf("%d\n", *it);
                st.erase(it);
            }
        }
    }
    return 0;
}
biset
    🔗 引用站外地址，请注意甄别
            
                    bitset
            517coding
        
            
    暴力
所有题目都要首先要写出暴力，然后再去思考优化。
管他能不能过，我们可以先把暴力当作找思路
观察到 $C \le 10000， N \le 1000$ （分别小于等于 $1$ 万和 $1$ 千）
直接开一个数组 $a[10010][1010]$ 
$a_{ij}$ 表示 $i$  是否属于 $j$ 集合
$a_{ij}=1$ 表示 $i$ 属于 $j$ 集合
$a_{ij}=0$ 表示 $i$ 不属于 $j$ 集合
这样的话就要每次 $O(N)$ 查询
但是询问有 $200000$ 个，整体的复杂度为 $O(NQ)$
直接下播
压位
$a$ 数组很明显有很多的浪费，因为它只是用来表示 $0$ 或 $1$ 的
然而一个 int 本身就有 $32$ 个 $0$ 或 $1$
所以可以对 $a$ 数组进行一些改编
开一个数组 $a[10010][40]$
相当于把 $1$ 千压成了 $40$
一个 int 是 $32$ 个位，$40$ 个 int 就可以表示 $1$ 千多个集合了
bitset 的使用方法
手写压位太麻烦了，各种位运算痛不欲生，有没有更简单的方法呢？
别忘了 STL 就是为了让代码量变少而生的
我们可以使用 STL 中的 bitset
定义： bitset<1010> b[10010]（注意：<> 里面必须是常数），可以理解为长度位 $1010$ 的二进制字符串
b[x].set(y) 把 $x$ 的第 $y$  设为 $1$
(b[x] & b[y]) 返回两个 bitset 与之后的新的 bitset
b[x].count() 返回 $b[x]$ 中 $1$ 的数量
b[x].flip(pos) 把 $b[x]$ 中的第 $pos$ 位 $0$ 变 $1$，$1$ 变 $0$ 
b[x].reset() 清空（把所有位设为 $0$ ）
b[x].any() 如果 $b[x]$ 至少有一位为 $1$，返回 true，否则返回 false
更多内容详见以下链接 
    🔗 引用站外地址，请注意甄别
            
                    C++ Forum
            cplusplus
        
            
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include 
using namespace std;


bitset<1010> a[10010];//用值当做下标
int main() {
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) {
        int k, x;
        scanf("%d", &k);
        while(k--) {
            scanf("%d", &x);
            a[x].set(i);//x和i在同一集合
        }
    }
    int Q;
    scanf("%d", &Q);
    while(Q--) {
        int x, y;
        scanf("%d%d", &x, &y);
        //如果两个与了之后不为0，就说明这两个有相同的1，即在同一集合
        if((a[x] & a[y]).any()) printf("Yes\n");
        else printf("No\n");
    }
    return 0;
}
矩阵切割
    🔗 引用站外地址，请注意甄别
            
                    矩阵切割
            517coding
        
            
    首先，我们发现，切痕可以用 set 维护
然后，我们发现，每切一刀，只改变这一维中某一块的大小，其他的都不变
而最大面积本质上讲就是横向的最大间距乘纵向的最大间距
当切一刀的时候其实只会改变一个间距，其他的间距都不会变，那么就可以把这个间距找出来，删掉，再插入两个新的间距
又因为间距会重复，所以需要两个 multiset 来维护间距 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include 
using namespace std;

set<long long> s1,s2;
multiset<long long> ss1,ss2;

int main() {
    long long w, h, n;
    scanf("%lld%lld%lld", &w, &h, &n);
    //插入边界
    s1.insert(w), s2.insert(h);
    s1.insert(0), s2.insert(0);
    ss1.insert(w), ss2.insert(h);
    for (int i = 1; i <= n; i++) {
        char c;
        int x;
        scanf(" %c %d", &c, &x);
        if(c == 'H') {
            //找到这个切痕的切面一个切痕和后面一个切痕
            auto it=s2.upper_bound(x),it2=s2.upper_bound(x);
            it2--;//注意这里要--
            long long k = (*it) - (*it2);
            ss2.erase(ss2.find(k));
            ss2.insert(x - (*it2)), ss2.insert((*it)-x);
            s2.insert(x);
        }
        else {
            auto it=s1.upper_bound(x),it2=s1.upper_bound(x);
            it2--;
            long long k=(*it)-(*it2);
            ss1.erase(ss1.find(k));
            ss1.insert(x - (*it2)), ss1.insert((*it)-x);
            s1.insert(x);
        }
        //最值相乘
        printf("%lld\n", *(--ss1.end()) * *(--ss2.end()));
    }
    return 0;
}



【提高组】第二课：贪心 学习笔记
sxr1023 — Wed, 24 Jan 2024 19:13:26 GMT
贪心
    🔗 引用站外地址，请注意甄别
            
                    第二课：贪心
            517coding
        
            
    A：最小字典序
    🔗 引用站外地址，请注意甄别
            
                    最小字典序
            517coding
        
            
    思路
贪心的去选取
例如样例 ACDBCB
开头和结尾相比，A 小，B 大，选择 A，此时 $t$ 为 A
字符串变成 CDBCB，B 小，C大，选 B，此时 $t$ 为 AB
看似只要开头和结尾不同就只要选择小的哪个就 OK 了，但是如果开头和结尾相同呢？
此时字符串为 CDBC，选择左边的 C 还是右边的 C 就值得思考了。
如果选择左边，接下来 $t$ 最终会变成 ABCCBD ，显然不是最优的，那么就应该先选择右边的 C，最终得到的才是正确的答案
正解
如果开头和结尾不同，那么就取较小的字符
当一个字符串的开头和结尾相同时，就要两边同时往里面看，一直看到两边不同为止。
假设向里面看到的两个不同的位置的字符从左到右分别是 $A$ 和 $B$ ，那么如果 $A$ 小于 $B$，就先取左边的开头，如果 $B$ 小于 $A$ ，那么就取右边的结尾
这样做的复杂度为 $O(n^2)$，而 $n$ 最大只有 $2000$，完全可以接受
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include 
using namespace std;

int main() {
    int n;
    scanf("%d", &n);
    string s;
    cin >> s;
    string t = "";
    int l = 0, r = n - 1;
    while(l <= r) {//两个变量维护开头和结尾
        //如果开头和结尾不同，就取较小的一个
        if (s[l] < s[r]) t += s[l], l++;
        else if (s[r] < s[l]) t += s[r], r--;
        else {
            //两个变量同时往里面缩
            int idx1 = l, idx2 = r;
            while(idx1 <= idx2 && s[idx1] == s[idx2]) idx1++, idx2--;
            if (s[idx1] < s[idx2]) t += s[l], l++;
            else t += s[r], r--;
        }
    }
    //别忘了每80个字符换行一次
    int len = t.size();
    for (int i = 0; i < len; i++) {
        cout << t[i];
        if ((i + 1) % 80 == 0) printf("\n");
    }
    return 0;
}
B：雷达
    🔗 引用站外地址，请注意甄别
            
                    雷达
            517coding
        
            
    直接按 $x$ 排序
直觉告诉我们，可以按照点的 $x$ 排序，这样的话这个雷达不仅可以把这个点覆盖，还有更多的机会取覆盖更右边的点
但是会有一个问题
假设有连个点，分别为 $C_1,C_2$，能够覆盖他们的雷达的最远位置分别是 $A_1,A_2$  ，它们格子距离雷达的长度分别是 $l_1,l_2$ 
那么如果选择了 $A_1$ ，就会错过 $C_2$ ，原因是因为，$C_2$ 距离 $x$ 轴是包含了高度的，这样计算的话，如果 $l_1$ 就等于 $d$ ，也就是雷达的最大半径，$A_1$ 就无法覆盖。原来的贪心策略出现了问题
正解
可以换一个角度思考这个问题
对于每一个点，设能够覆盖到它的最远的雷达分别为 $B_1,B_2 $
那么这两个点就构成了一个区间
如图，红色的点的位置为 $(x,y)$，设点 $P$ 的左边为 $(x,y)$ ，那么 $B_1,B2$ 的 $y$ 坐标肯定都是 $0$ ，$x$ 坐标分别为 $x-\sqrt{d^2-y^2}$ 和 $x+\sqrt{d^2-y^2}$（关于原理论证，详见下）
也就是说，在 区间$[x-\sqrt{d^2-y^2}，x+\sqrt{d^2-y^2}]$ 内任意选一个雷达，都可以覆盖掉这个点
那么就可以得出这么一个结论，所有的点都可以转化成若干段区间。
原问题就被转换成了一个新的问题，即给你若干个区间，选择最少的点，使得每个区间内都有点
新问题中的“点”其实就是雷达，根据模型转换的思想，就不需要管原问题了
论证
还是上面这个图
设左边黄色的线上的点是 $B_1$ ，右边黄色的线上的点是 $B_2$ ，红色的点为 $P$ 
我们观察到到三角形 $PB_1B_2$ 中的一条紫色的先把这个三角形分成两半，而且是两个直角三角形
直角三角有一个至关重要的结论——勾股定理，也就是 $a^2+b^2=c^2$ 
那么，现在我们把这个公式倒过来用
设点 $P$ 的坐标为 $(x,y)$ 
已知紫色的线于 $x$ 轴垂直，设垂足为 $Q$
已知三角形 $PB_1Q$ 的斜边长度为 $d$ ，高的长度为 $y$ ，在勾股定理中分别代表 $a$ 和 $c$ 
那么就可以得到 $d^2$ 和 $y^2$ ，即勾股定理中的 $a^2$ 和 $c^2$ 
那么就已知 $a^2$ 和 $c^2$ 
$\because a^2+b^2=c^2$
$\therefore b^2=c^2-a^2$
$\therefore b=\sqrt{c^2-a^2}$
数学语言不太标准，勿喷
区间覆盖问题
通过模型转化，得到以下新问题
给你若干个区间，求至少多少个点，可以覆盖所有区间
因为选择右端点可以尽可能多的覆盖区间，所以贪心的策略就是只选右端点
一定存在这样一种答案，所有选择的点都是右端点
按照右端点排序
用变量 $R$ 维护当前选区的右端点
如果下一个区间的左端点小于 $R$ ，那么就不用管这个区间了，这个区间会直接被覆盖
无解的情况
当我们发现输入的点的 $y$ 坐标大于 $d$ 时，就是误解
不推荐在输入时 break ，尤其是多组数据，会出问题
注意：这道题目有负数，但只要特判无解的时候加上 fabs 或者 abs 就行了
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include
using namespace std;

const int N = 1010;
double x[N], y[N];

int n, r;
//转换后的区间
pair<double, double> a[N];
void init() {
    for(int i = 1;i <= n; i++) {
        double tmp = sqrt(r * r - y[i] * y[i]);
        a[i].first= x[i] - tmp;
        a[i].second = x[i] + tmp;
    }
}

bool cmp(pair<double, double> _x, pair<double, double> _y) {
    return _x.second < _y.second;
}
int main() {
    scanf("%d%d", &n, &r);
    int flag = 0;
    for (int i = 1; i <= n; i++) {
        scanf("%lf%lf", &x[i], &y[i]);
        if (fabs(y[i]) > r) flag = 1;//注意y[i]可能是负数
    }
    //特判无解
    if (flag == 1) {
        printf("-1\n");
        return 0;
    }
    init();
    sort(a + 1, a + n + 1, cmp);//排序，右端点越大越靠前
    double R = a[1].second;
    int ans = 1;
    for(int i = 1;i <= n; i++)
        if(a[i].first > R) R = a[i].second, ans++;
    printf("%d\n", ans);
    return 0;
}
C：机器分配
    🔗 引用站外地址，请注意甄别
            
                    机器分配
            517coding
        
            
    把机器和任务转化成点
我们可以把机器和任务都转化成平面直角坐标系上的点
一个机器要想完成一个任务，那么代表这个机器的点必须在代表任务的点的上方或右方或右上方
从分数入手
题目中说完成一个任务的分数为 $500x+2y$ 
显然，$x$ 增加 $1$ ，分数就会增加 $500$ ，$y$ 增加 $1$ ，分数就会增加 $2$ ，而 $y$ 最大只有 $100$ 
这样就可以得出一个结论：优先去做 $x$ 较大的任务
但是题目的第一需求时完成任务的数量较多，第二需求是分数较多
优先完成 $x$ 较大的任务会不会导致完成的任务的数量变少呢？
肯定是会影响答案的
那么在任务选择机器的时候，就应该选择最合适的机器，性价比最高的机器
就是说只要这个机器能完成当前的任务就先顶了，没必要让机器大出任务很多
正解
把机器和任务分别都按照 $x$ 从大到小排序
在任务数组里面设置一个 $i$ 指针，在机器数组里面设置一个 $j$ 指针，因为数组已经按照 $x$ 排序，所以可以让 $j$ 不断滑动，滑动到刚好 $j$ 位置的 $x$ 大于等于当前任务的 $x$ 并且 $j$ 位置的 $x$ 小于当前任务的 $x$ 
得到这样的一个 $j$ 后，只需要在 [$1,j$] 区间中找一个最合适的机器即可（假设下标从 $1$ 开始）
此时，机器的 $x$ 已经没有用了，因为我已经知道 [$1,j$] 区间中所有的机器的 $x$ 都大于当前的任务的 $x$ ，所有不用再考虑 $x$ 了。为了性价比最高，应当选择 [$1,j$] 区间中 $y$ 最小的机器，并且这个机器的 $y$ 大于任务的 $y$ 
注意开 long long
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include 
using namespace std;

const int N = 100010;

int cnt[110];
struct node {
    int x, y;
    //重载小于号运算符
    bool operator < (const node &cmp) const {
        if (x != cmp.x) return x > cmp.x;
        return y > cmp.y;
    }
} a[N], b[N];

int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++) {
        scanf("%d%d", &a[i].x, &a[i].y);
    }
    for (int i = 1; i <= m; i++) {
        scanf("%d%d", &b[i].x, &b[i].y);
    }
    sort(a + 1, a + n + 1);
    sort(b + 1, b + m + 1);
    //注意开long long
    long long ans1 = 0, ans2 = 0;
    for (int i = 1, j = 1; i <= m; i++) {
        while(j <= n && a[j].x >= b[i].x) {
            cnt[a[j].y]++;//桶
            j++;
        }
        //利用桶排序的效率更高
        for (int k = b[i].y; k <= 100; k++) {
            if (cnt[k]) {
                ans1++;
                ans2 += 500LL * b[i].x + 2LL * b[i].y;
                cnt[k]--;
                break;
            }
        }
    }
    printf("%lld %lld\n", ans1, ans2);
    return 0;
}



【提高组】第一课：枚举 学习笔记
sxr1023 — Tue, 23 Jan 2024 19:07:11 GMT
枚举
    🔗 引用站外地址，请注意甄别
            
                    第一课：枚举
            517coding
        
            
    A：dfs暴力枚举，二进制枚举
    🔗 引用站外地址，请注意甄别
            
                    按钮变色
            517coding
        
            
    题意：最少操作几次是的所有格子变成同色
以某个格子为中心的翻转最多只会有一次
同样的一个格子不会作为中心被翻转两次
解法
暴力枚举每个格子翻或者不翻，最后检测是否全部同色，如果全部同色，看一下操作几次，更新答案
change 函数改变 $x,y$  及周边格子的颜色
check 函数判断格子颜色是否全部相同
dfs 函数暴力枚举。dep 参数是搜到了哪个位置（最大16），used 参数记录翻转的次数
不凡当前格子就去 dep + 1 位置，used 不变
翻转当前格子就去 dep + 1 位置，used + 1
注意回溯！因为 used 作为参数，所以不用回溯，只要回溯 mp 数组即可
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include 
using namespace std;

char mp[10][10];

//5个方向
int dx[] = {0, 0, 1, 0, -1};
int dy[] = {0, 1, 0, -1, 0};

int ans = 20;
void change(int x, int y) {
    for (int i = 0; i < 5; i++) {
        int ax = x + dx[i];
        int ay = y + dy[i];
        if (ax < 0 || ax > 4 || ay < 0 || ay > 4)
            continue;
        if (mp[ax][ay] == 'w') mp[ax][ay] = 'b';
        else mp[ax][ay] = 'w';
    }
}
bool check() {
    char x = mp[0][0];
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            if (mp[i][j] != x) return false;
        }
    }
    return true;
}
void dfs(int dep, int used) {
    if (dep == 16) {
        if (check()) ans = min(ans, used);
        return ;
    }
    dfs(dep + 1, used);
    int x = dep / 4, y = dep % 4;
    change(x, y);
    dfs(dep + 1, used + 1);
    change(x, y);//回溯 
}
int main() {
    for (int i = 0; i < 4; i++) {
        scanf("%s", mp[i]);
    }
    dfs(0, 0);//最开始在第0层 
    if (ans == 20) printf("Impossible\n");//注意判断无解
    else printf("%d\n", ans);
    return 0;
}
状态压缩
用一个整数的二进制来表示某个元素选或不选
B：双指针（尺取法）
    🔗 引用站外地址，请注意甄别
            
                    最短连续子序列
            517coding
        
            
    题意：给你 $n,S$ 以及 $n$ 个数，求最短的连续子序列的长度似的这个连续子序列的和大于等于 $S$ （$n \le 10^5$）
暴力
暴力枚举所有的区间，求和，判断
如果不用前缀和优化，复杂度为 $O(n^3)$ 
使用前缀和优化，复杂度为 $O(n^2)$ 
二分
预处理前缀和 $sum_i$ 表示前 $i$ 个数的和
枚举区间的左端点，此时发现越往右和越大，所以满足单调性，可以二分找到满足条件的最小的右端点，更新答案 
复杂度为 $O(nlogn)$ 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include 
using namespace std;

const int N = 100010;

int a[N], sum[N];
int main() {
    int n, s;
    scanf("%d%d", &n, &s);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
        sum[i] = sum[i - 1] + a[i];
    }
    int ans = n + 1;
    //枚举左端点
    for (int i = 1; i <= n; i++) {
        //在 [i,n] 区间内去找一个满足条件的最小的右端点
        int l = i, r = n, best = -1;
        while(l <= r) {
            int mid = (l + r) / 2;
            if (sum[mid] - sum[i - 1] >= s) {
                best = mid;
                r = mid - 1;
            }
            else l = mid + 1;
        }
        if (best != -1) ans = min(ans, best - i + 1);
    }
    if (ans == n + 1) printf("0\n");//判断无解
    else printf("%d\n", ans);
    return 0;
}
双指针
枚举其中一个端点，另一个端点在滑动
值得的注意的是，右端点 $j$ 在滑动的时候不应当判断 $j$ 是否合法，而应当判断 $j+1$  位置是否合法，因为只有这样，才能尽可能的找打最靠右的右端点
$j$ 初始值为 $0$ 是因为滑动以下就到了 $1$ ，不然的话会忽略第一个位置
$tmp$ 维护区间和
复杂度为 $O(n)$ 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include 
using namespace std;

const int N = 100010;

int a[N];
int main() {
    int n, s;
    scanf("%d%d", &n, &s);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
    }
    int j = 0;
    int tmp = 0;
    int ans = n + 1;
    //确定左端点
    for (int i = 1; i <= n; i++) {
        //右端点进行滑动
        //尽可能地向右找
        while(j + 1 <= n && tmp < s) tmp += a[j + 1], j++;
        if (tmp >= s) ans = min(ans, j - i + 1);
        tmp -= a[i];//左端向右滑动，因此总和要减掉这个数
    }
    if (ans == n + 1) printf("0\n");
    else printf("%d\n", ans);
    return 0;
}
C：异或
    🔗 引用站外地址，请注意甄别
            
                    异或和
            517coding
        
            
    异或的性质
两个位不同才为 $1$
$101$ 异或 $010 = 111$
假如 $a$ ^ $b < a + b$ （此处 ^ 为异或符号）
说明什么？说明 $a$ ^ $b$  ^ $c$ 一定也小于 $a + b + c$ 
那么以后所有的数相异或都不会相等了
解法
利用这个特质，可以得出解法：
枚举一个左端点，然后利用双指针（two-pointers）技巧去滑动右端点，找到最大的满足条件的右端点
右端点滑动：假设我们枚举到一个左端点 $i$ ，接下来我们要用一个 $j$ 代表右端点，不断进行滑动
设 $SA$ 为当前 $[i,j - 1]$ 区间的元素异或和，$x$ 等于 $a_j$ ，$sum$ 为 [$i,j - 1$] 区间和
 如果 $SA$ ^ $x$ 等于 $sum + x$，那么 $j$ 就可以一直向右滑动
一直滑倒一个最极限的位置为止
所以 $[i,i],[i,i+1],[i,i+2]…[i,j]$ 都是满足条件的
答案就可以就可以加上 $j-i+1$ 
左端点移动：当我们扔掉 $i$ 位置的数时，这段区间其实是更加满足条件的，这是因为如果 $a$ ^ $b$ ^ $c=a+b+c$，那么如果把 $c$ 让掉，$a$ ^ $b$ 也一定是等于 $a+b$ 的
所以 $j$ 就没有必要从头开始，可以继续向右滑动，重复上面的操作，计算答案，复杂度就变成了 $O(n)$ 
和上一题不同的时，这题需要维护两个和，分别是异或和和区间和
不开 long long 见祖宗
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include 
using namespace std;

const int N = 200010;

int a[N];
int main() {
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
    }
    int j = 0;
    int suma = 0, sumb = 0;//suma维护异或和，sumb维护区间和
    long long ans = 0;
    for (int i = 1; i <= n; i++) {
        //注意异或的优先级比较低，要加括号
        while(j + 1 <= n && (suma ^ a[j + 1]) == (sumb + a[j + 1]))
            suma ^= a[j + 1], sumb += a[j + 1], j++;
        //这里不需要判断j的越界情况，j因为上面的while循环最大会停留在n
        ans += j - i + 1;
        suma ^= a[i];//同一个数异或两次相当于没有异或
        sumb -= a[i];
    }
    printf("%lld\n", ans);
    return 0;
}
D：折半枚举
    🔗 引用站外地址，请注意甄别
            
                    最大余数
            517coding
        
            
    题意
给你最多 $35$ 个整数，选出一个子集使得这个子集的和区域 $m$ 最大，求最大余数
子集就是某一个组合
暴力枚举所有组合复杂度 $2^{35}$ 
解法
分成两半之后，暴力枚举前一半数的所有组合，保存到 $b$ 数组并进行排序，复杂度最多为 $2^{18}$ 
暴力枚举另一半的所有组合，去 $b$ 数组里面寻找一个数，使得这个数跟 $x$ 加起来模 $m$ 最大
去 $b$ 数组里面查找小于等于 $m - 1 - x$ 的最大的一个数，如果不存在就直接取 $b$ 数组里面最大的数
所以问题就变成了在一个有序数组中查找某一个数，用二分解决
可以利用二进制枚举，注意：二进制枚举时下标一般从 $0$ 开始
注意：$b$ 数组要开的很大，否则会 RE 或 WA
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#include 
using namespace std;

const int N = 300010;//数组至少要这么大
int a[N], b[N];

int n, mod, tot;
//在b数组里二分，找到小于等于x的最大的数，找不到则返回b数组中最大的数
int find(int x) {
    if (b[0] > x) return b[tot - 1];
    int l = 0, r = tot - 1, best = -1;
    while(l <= r) {
        int mid = (l + r) / 2;
        if (b[mid] <= x) {
            best = mid;
            l = mid + 1;
        }
        else r = mid - 1;
    }
    return b[best];
}
int main() {
    scanf("%d%d", &n, &mod);
    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
        a[i] %= mod;
    }
    int m = n / 2;
    int ans = 0;
    //第一半的组合，保存在b数组
    for (int i = 0; i < (1 << m); i++) {
        int tmp = 0;
        for (int j = 0; j < m; j++) {
            if (i & (1 << j)) tmp = (1LL * tmp + a[j]) % mod;//注意1LL，小心溢出
        }
        b[tot++] = tmp;
        ans = max(ans, tmp);//特殊处理再某一半的最大组合
    }
    sort(b, b + tot);
    m = n - (n / 2);
    for (int i = 0; i < (1 << m); i++) {
        int tmp = 0;
        for (int j = 0; j < m; j++) {
            //因为开始点是从n/2开始的，所以要加上这些偏移量
            int jj = j + n / 2;
            //cout << i << " " << jj << " " << (1 << jj) << endl;
            if (i & (1 << j)) tmp = (1LL * tmp + a[jj]) % mod;
        }
        //特殊处理再某一半的最大组合
        ans = max(ans, tmp);
        int x = find(mod - tmp - 1);//尽量找最接近mod - 1的数
        ans = max(ans, (x + tmp) % mod);//这里注意取模
    }
    printf("%d\n", ans);
    return 0;
}

sxr1023's Blog

如何给博客快速添加封面

开始之前

图片选择

为什么使用

使用教程

butterfly标签外挂美化

常用标签外挂效果

Hexo博客美化前置教程

前言

高频目录

DIFF 语言

引入自定义js和css文件

全局变量参考

个人经验杂谈

【提高组】第六课：状态压缩DP/子集枚举 学习笔记

第六课：状态压缩DP/子集枚举

A：环游世界

B：数字重排

暴力

状态压缩

C：开门迷宫

E：回文子序列删除

P10112 [GESP202312 八级] 奖品分配 题解

P10109 [GESP202312 六级] 工作沟通 题解

【提高组】第五课：动规 学习笔记

第五课：动规

A：最少末尾零

B：凑硬币

【提高组】第四课：三分/01分数规划 学习笔记

三分/01分数规划

A：点到线段的距离

三分

B：三角形与四边形

C：最大比例

转化

单调性

D：后缀零

怎样求 $n!$ 末尾有多少个0

单调性

二分的上界

E ：最小距离最大化

F：矩阵

解法

【提高组】第三课：STL 学习笔记

STL

A：水果店

map 的定义

map 的遍历

迭代器

auto 进行遍历

map 的用法

Set

set 的用法

基本用法

lower_bound 和 upper_bound

multiset 和 set 的区别

biset

暴力

压位

bitset 的使用方法

矩阵切割

【提高组】第二课：贪心 学习笔记

贪心

A：最小字典序

思路

正解

B：雷达

直接按 $x$ 排序

正解

论证

区间覆盖问题

无解的情况

C：机器分配

把机器和任务转化成点

从分数入手

正解

【提高组】第一课：枚举 学习笔记

枚举

A：dfs暴力枚举，二进制枚举

【提高组】第六课：状态压缩DP/子集枚举学习笔记

`A：环游世界`

P10112 [GESP202312 八级] 奖品分配题解

P10109 [GESP202312 六级] 工作沟通题解

【提高组】第五课：动规学习笔记

【提高组】第四课：三分/01分数规划学习笔记

【提高组】第二课：贪心学习笔记

【提高组】第一课：枚举学习笔记