涡の小屋

[猜盐] 是否猜国的最优解法

Sun, 08 Feb 2026 00:00:00 GMT

前言

猜盐猜盐猜盐猜盐猜盐

最近沉迷猜盐无法自拔。做是否猜国的时候~~作为一名蒟蒻OIer~~一下就想到了可以用二分来最小化最大提问次数，遂写此文。

声明：本文所指的国家来源为猜盐上的世界上的国家，仅作为“是否猜国”的参考用，不代表本站任何立场。

理论

问题描述：在是否猜国中，你需要通过提出问题猜测一个国家，而AI会回答这个问题对于这个国家是正确的还是错误的（或者未知）。你也可以直接提出这个国家的名字。如果名字正确则直接结束。也就是说，一次对话有四个结果：是、否、正确和未知。

本文只讨论是或否的情况。

（我试过在一次对话里面塞两个问题去利用正确和未知这两个状态来减少提问次数，可是不是很稳定。所以我们只讨论是否两种情况）

注意到，对于n个对象二分的最大次数$T$ 为

$$ T=\lceil \log_2 n \rceil $$

对197个国家进行二分的最大次数为 $\lceil \log_2 197 \rceil = 8$ 次。

由于猜盐最后一次“正确”也算在次数内，所以实际上二分的最大提问数为9次。

二分方法

根据以上的理论，我构建了一个可行的二分猜国的规则。

为了简洁性，以下的树只列出了前五个问题，把国家的范围缩小到8个以内。读者可以自行找出对剩下的国家进行二分的方法，或者直接复制一半的国家问AI答案在不在这里面。

任何错误/更优雅的方法也请各位评论指出{{{(>_<)}}}

我们开始吧！(=^^)///

亚欧 (92)
- 大部分国土位于亚洲（包括俄罗斯） (49)
  - 中/西亚 (23)
    - 阿拉伯国家 (12)
      - 三个字 (6) ：伊拉克/科威特/黎巴嫩/阿联酋/卡塔尔/叙利亚
      - 非三个字 (6) ：约旦/巴勒斯坦/沙特阿拉伯/也门/阿曼/巴林
    - 不是阿拉伯国家 (11)
      - 中亚(5) ：哈萨克斯坦/塔吉克斯坦/乌兹别克斯坦/吉尔吉斯斯坦/土库曼斯坦
      - 西亚(6) ：以色列/土耳其/塞浦路斯/格鲁吉亚/亚美尼亚/阿塞拜疆
  - 东/东南/南/北亚(26)
    - 东南亚 (11)
      - 两个字（不包括印尼）(5) ：缅甸/老挝/越南/泰国/文莱
      - 两个字以上（包括印度尼西亚）(6) ：柬埔寨/印度尼西亚/马来西亚/东帝汶/菲律宾/新加坡
    - 东/南/北亚 (15)
      - 两个字 (8) ：中国/蒙古/朝鲜/韩国/日本/伊朗/印度/不丹
      - 三个字及以上 (7) ：斯里兰卡/马尔代夫/巴基斯坦/孟加拉国/尼泊尔/阿富汗/俄罗斯
- 大部分国土位于欧洲（不包括俄罗斯）(43)
  - 欧盟(27)
    - 名字结尾为牙/亚/兰/利 (15)
      - 名字结尾为牙/亚(8) ：西班牙/葡萄牙/斯洛文尼亚/克罗地亚/罗马尼亚/保加利亚/爱沙尼亚/拉脱维亚
      - 名字结尾为兰/利(7) ：*荷兰/波兰/芬兰/爱尔兰/意大利/匈牙利/奥地利 *
    - 名字结尾不为以上的字 (12)
      - 两个字 (6) ：捷克/丹麦/希腊/瑞典/德国/法国
      - 三或四个字 (6) ：比利时/卢森堡/马耳他/立陶宛/斯洛伐克/塞浦路斯
  - 非欧盟(16)
    - 巴尔干半岛/东欧(8) ：塞尔维亚/北马其顿/波黑/黑山/阿尔巴尼亚/白俄罗斯/乌克兰/摩尔多瓦
    - 非巴尔干半岛/东欧(8) ：冰岛/英国/挪威/瑞士/安道尔/列支敦士登/圣马力诺/梵蒂冈
非亚欧(105)
- 非洲(54)
  - 北/东部非洲 (24)
    - 阿拉伯国家联盟成员国 (9)
      - 三个字 (6) ：利比亚/摩洛哥/突尼斯/吉布提/索马里/科摩罗
      - 非三个字(3) ：阿尔及利亚/埃及/苏丹
    - 非阿拉伯国家联盟成员国 (15)
      - 三个字 (8) ：肯尼亚/乌干达/卢旺达/布隆迪/赞比亚/马拉维/南苏丹/塞舌尔
      - 非三个字 (7) ：埃塞俄比亚/厄立特里亚/马达加斯加/坦桑尼亚/津巴布韦/毛里求斯/莫桑比克
  - 中/西/南部非洲 (30)
    - 西部非洲(16)
      - 两/三个字 (8) ：马里/加纳/多哥/贝宁/尼日尔/佛得角/几内亚/冈比亚
      - 四/五个字 (8) ：塞内加尔/塞拉利昂/利比里亚/科特迪瓦/尼日利亚/几内亚比绍/布基纳法索/毛里塔尼亚
    - 中/南部非洲(14)
      - 两/四个字 (7) ：乍得/中非/加蓬/南非/纳米比亚/博茨瓦纳/斯威士兰
      - 非两/四个字(7) ：莱索托/刚果金/刚果布/安哥拉/喀麦隆/赤道几内亚/圣多美和普林西比
- 南北美/大洋 (51)
  - 北/中美洲（包括巴拿马）(23)
    - 岛国 (13)
      - 四个字 (5) ：多米尼加/多米尼克/圣卢西亚/巴巴多斯/格林纳达
      - 非四个字 (8) ：古巴/海地/牙买加/巴哈马/圣基茨和尼维斯/安提瓜和巴布达/圣文森特和格林纳丁斯/特立尼达和多巴哥
    - 非岛国 (10)
      - 两/三个字 (5) ：美国/加拿大/墨西哥/伯利兹/巴拿马
      - 四/五个字 (5) ：危地马拉/萨尔瓦多/洪都拉斯/尼加拉瓜/哥斯达黎加
  - 南美洲/大洋洲 (28)
    - 南美（不包括巴拿马）(12)
      - 三个字 (5) ：阿根廷/苏里南/乌拉圭/巴拉圭/圭亚那
      - 二/四个字 (7) ：巴西/智利/秘鲁/委内瑞拉/哥伦比亚/厄瓜多尔/玻利维亚
    - 大洋(16)
      - 二/三个字 (8) ：帕劳/斐济/汤加/瑙鲁/纽埃/图瓦卢/萨摩亚/新西兰
      - 四个字及以上 (8) ：澳大利亚/巴布亚新几内亚/密克罗尼西亚联邦/马绍尔群岛/基里巴斯/所罗门群岛/瓦努阿图/库克群岛

注

地理区划原则：联合国地理区划

所以伊朗和阿富汗属于南亚

名字：国家常用称呼

法兰西第五共和国❌ 法国✅

有的时候猜盐的判定很谜，所以实际运用这个方法的时候可能会比最优解更少或者更多。

实战：

记 2025 SCIE 1024 Coding Challenge

Tue, 28 Oct 2025 00:00:00 GMT

关于比赛

本届 SCIE 1024 程序员节活动由 M&CS Club 和 SCIE MLxAI 两个社团联合举办，设有两条赛道，算法和机器学习。我参加了算法的比赛，AK并取得了第二的成绩~

此次比赛从周五下午的八点开始，持续两天。可以说时间非常充足了

比赛题目pdf可点击此处下载

题目思路

以下是我的解题思路和对题目评价/吐槽（有些比较简单的就写得比较少）

Enjoy~

CR(字典序) : Alex Liu, Allen Xu, Alvin, CQR, Tiger Shu

A~D

水题略

E (T5)

结合了课内FDE Cycle的模拟题，让人眼前一亮。但测试样例有点少，对于循环次数和报错 CRASH 的说明不够清晰，debug到自闭😭

F (T6)

一道搜索题。用双向BFS优化了下速度，写了个简单的哈希表来标记已访问的图

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

struct grid{
    int grid[3][3];
    bool side;
};

int prime[9] = {2,3,5,7,11,13,17,19,23}; // Hash
int hash_grid(grid x){
    unsigned long long res = 0;
    for(int i=0;i<3;i++){
        for(int j=0;j<3;j++){
            res += prime[i*3+j]*x.grid[i][j];
        }
    }
    return res % 114514;
}

struct node{
    grid x;
    vector<int> o;
};

vector<node> visited[114514];
queue<node> ss, ee;

bool comp(grid a, grid b){
    bool res = false;
    for(int i=0;i<3;i++){
        for(int j=0;j<3;j++){
            if(a.grid[i][j] != b.grid[i][j])return false;
        }
    }
    return true;
}

bool searched(node x){
    int hashed = hash_grid(x.x);
    if(empty(visited[hashed]))return false;
    for(int i=0;i<visited[hashed].size();i++){
        if(comp(x.x, visited[hashed][i].x)){
            return true;
        }
    }
    return false;
}

node searched_grid(node x){
    int hashed = hash_grid(x.x);
    for(int i=0;i<visited[hashed].size();i++){
        if(comp(x.x, visited[hashed][i].x)){
            return visited[hashed][i];
        }
    }
}

void search(node x){
    visited[hash_grid(x.x)].push_back(x);
}

int step[4][2] = {{0,0},{0,1},{1,0},{1,1}};
node spin(node x, int opt){
    int i = step[opt][0];
    int j = step[opt][1];
    int cache = x.x.grid[i][j];
    x.x.grid[i][j] = x.x.grid[i+1][j];
    x.x.grid[i+1][j] = x.x.grid[i+1][j+1];
    x.x.grid[i+1][j+1] = x.x.grid[i][j+1];
    x.x.grid[i][j+1] = cache;
    return x;
}

node spinrev(node x, int opt){
    int i = step[opt][0];
    int j = step[opt][1];
    int cache = x.x.grid[i][j];
    x.x.grid[i][j] = x.x.grid[i][j+1];
    x.x.grid[i][j+1] = x.x.grid[i+1][j+1];
    x.x.grid[i+1][j+1] = x.x.grid[i+1][j];
    x.x.grid[i+1][j] = cache;
    return x;
}

void output_node(node x){
    cout<<x.x.side<<":";
    for(int i=0;i<x.o.size();i++)cout<<x.o[i]<<',';
    cout<<endl;
    for(int i=0;i<3;i++){
        for(int j=0;j<3;j++){
            cout<<x.x.grid[i][j]<<' ';
        }
        cout<<endl;
    }
    cout<<"-------"<<endl;
}

string code = "ABCDXXXXXX";
int main(){
    node start;
    for(int i=0;i<3;i++){
        for(int j=0;j<3;j++){
            start.x.grid[i][j] = i*3+j+1;
        }
    }
    start.x.side = true;

    node end;
    for(int i=0;i<3;i++){
        for(int j=0;j<3;j++){
            cin>>end.x.grid[i][j];
        }
    }
    end.x.side = false;
    ss.push(start);ee.push(end);

    vector<node> ans;
    bool STOP = false;
    int count = 0;

    while(!STOP){ // BFS
        node s_top = ss.front(); // From the start
        ss.pop();
        for(int opt=0;opt<4;opt++){
            node cc = spin(s_top, opt);
            cc.o = s_top.o;
            cc.o.push_back(opt);

            if(searched(cc)){
                node awa = searched_grid(cc);
                if(awa.x.side == true){ // Same side
                    continue;
                }else{ /////ANSWER!!
                    ans.push_back(cc);
                    ans.push_back(awa);
                    STOP = true;
                    break;
                }
            }
            search(cc);
            ss.push(cc);
        }
        
        if(STOP)break;

        node e_top = ee.front(); // From the end
        ee.pop();

        for(int opt=0;opt<4;opt++){
            node cc = spinrev(e_top, opt); // Spin in reverse direction
            cc.o = e_top.o;
            cc.o.push_back(opt);

            if(searched(cc)){
                node awa = searched_grid(cc);
                if(awa.x.side == false){ // Same side
                    continue;
                }else{ /////ANSWER!!
                    ans.push_back(awa);
                    ans.push_back(cc);
                    STOP = true;
                    break;
                }
            }
            search(cc);
            ee.push(cc);
        }

        if(STOP)break;
    }

    cout<<"YES"<<endl;
    for(int i=0;i<ans[0].o.size();i++){
        cout<<code[ans[0].o[i]];
    }
    for(int i=ans[1].o.size()-1;i>=0;i--){
        cout<<code[ans[1].o[i]];
    }
    cout<<endl;

    return 0;
}

G (T7)

刚开始看到有图以为这也是一道搜索题，写了个深搜，TLE之后就去做别的题了。后面才发现其实有更巧妙的解法

考虑一个 $k$，使得所有边权包含 $2^k$ 的边可以让起点和终点联通（包含：指 $w&2^k=1$ ）。那么，当 $k$ 取最大时，最终答案的路径一定取自这些包含 $2^k$ 的边。证明如下：

因为结果是按位与出来的，不连通就意味着按位与后为0，取不到这一位，所以答案一定不来自包含大于 $2^k$ 的边。而如果答案来自包含小于$2^k$的边，那么它们所构成的答案肯定不包含 $2^k$ ，就会比我们用包含 $2^k$ 的边所构建出的答案更小，不满足最大化

所以，我们可以从最高位往下找 $k$ 。每次找到一个可以让起点和终点联通的边时，删除其他所有的边，只保留包含 $2^k$ 的边。记录一路上符合条件的 $2^k$ 的和，我们就可以得到最终的答案

判断是否联通的话可以使用并查集。每次初始化后添加没有被删除的边，然后就可以判断起点和终点是否被联通

#include<bits/stdc++.h>
using namespace std;
#define MAX 200009
#define int long long

int n, m;
int valid[MAX];

struct line{
    int from;
    int to;
    int val;
}lines[MAX];
int lines_tot;


void pushline(int a, int b, int val){
    lines[lines_tot].from = a;
    lines[lines_tot].to = b;
    lines[lines_tot].val = val;
    valid[lines_tot] = true;
    lines_tot++;
}

int bcj[MAX];

void bcj_init(){
    for(int j=0;j<=n;j++){
        bcj[j] = j;
    }
}

int bcj_find(int k){
    if(bcj[k] == k)return k;
    bcj[k] = bcj_find(bcj[k]);
    return bcj[k];
}

void bcj_merge(int a, int b){
    a = bcj_find(a); b = bcj_find(b);
    bcj[a] = b;
}

signed main(){ // n>300
    cin>>n>>m;
    for(int i=0;i<m;i++){
        int a,b,val;
        cin>>a>>b>>val;
        pushline(a,b,val);
    }

    int ans = 0;
    for(int k=30;k>=0;k--){
        bcj_init();
        for(int i=0;i<lines_tot;i++){
            if(valid[i]&&(lines[i].val & (1<<k))){
                bcj_merge(lines[i].from, lines[i].to);
            }
        }
        if(bcj_find(1) == bcj_find(n)){ // If available
            ans += (1<<k);
            for(int i=0;i<lines_tot;i++){
                if(!(lines[i].val & (1<<k))){
                    valid[i] = false; // Disable the edge
                }
            }
        }
    }
    cout<<ans;
    return 0;
}

H (T8)

一道很板子的树形dp

对于每棵子树，我们都可以分为两种情况：它的祖先没有进行翻转和进行了翻转（翻转：指操作2，翻转子树）（如果偶数个祖先都翻转了，则视为没有翻转，奇数同理）。所以我们可以在每个节点维护两个值 ans[0] 和 ans[1] ，分别代表在它的祖先不翻转和翻转的情况下，这棵子树需要多少次操作才能让这个子树都变为正常

也就是说：

对于叶子节点来说，如果祖先没有翻转 ans[0] ，那么当它被损坏时操作次数为1，否则为0. 如果祖先翻转了 ans[1] ，那么就反过来

对于非叶子节点来说，我们可以分类讨论一下

记我自身的状态为 status（损坏为0，正常为1）,也就是说我没被祖先翻转的操作次数为 !status ，被翻转后的操作次数为 status ，则

祖先没有翻转（求 ans[0] ）：
- 我不翻转，结果为我改变自己的操作次数 !status ，加上子节点们不翻转 ans[0] 的操作次数
- 我翻转，结果为我翻转后改变自己的操作次数 status ，加上子节点们翻转 ans[1] 的操作次数，再加上我翻转产生的操作次数1
- 最后， ans[0] 为两者的最小值
祖先翻转了（求 ans[1] ）：
- 我不翻转，结果为祖先翻转后我改变自己的操作次数 status ，加上子节点们翻转 ans[1] 的操作次数
- 我翻转，两个翻转产生的效果抵消，结果为我改变自己的操作次数 !status ，加上子节点们不翻转 ans[0] 的操作次数，再加上我翻转产生的操作次数1
- 最后， ans[1] 为两者的最小值

后序遍历整个树，从下到上更新每个节点的ans，最后的答案就为根节点不翻转 ans[0] 和根节点翻转 ans[1] 加1的最小值

Talk is cheap, show me the code.

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

struct node{
    vector<int> sons;
    int ans[2];
}tree[MAX];

bool status[MAX];
void dp(int k){
    // Leaf
    if(tree[k].sons.empty()){
        tree[k].ans[0] = !status[k];
        tree[k].ans[1] = status[k];
        return;
    }
    // Not Leaf
    int tot = 0;
    int tot_inv = 0;
    for(int i = 0; i < tree[k].sons.size(); i ++){
        dp(tree[k].sons[i]);
        tot += tree[tree[k].sons[i]].ans[0];
        tot_inv += tree[tree[k].sons[i]].ans[1];
    }
    tree[k].ans[0] = min(!status[k] + tot, status[k] + tot_inv + 1);
    tree[k].ans[1] = min(status[k] + tot_inv, !status[k] + tot + 1);
}

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

    for(int i = 1; i < n; i ++){
        int a, b;
        cin>>a>>b;
        tree[a].sons.push_back(b);
    }

    dp(1);

    cout<<min(tree[1].ans[0], tree[1].ans[1]+1); // Answer
    return 0;
}

I (T9)

3操作本质上是对x, y上的状态进行反转，总和不变

反转后原本的放置地雷变为删除地雷，删除地雷变为放置地雷。注意如果原本没有雷的情况下不能删除，有雷的情况下无法放置

而和的话，对于放置操作，则要添加这个雷周围的空位的数量，删除周围雷的数量（挡住了它的一个格子）。如果是删除的话，删除周围空位的数量后，也需要考虑周围雷的数量，重新加到和里面（释放一个格子给周围的雷）

对于雷的存储和查找，我维护了一个动态的二维数组。存储是线性复杂度，更常用的查找只有对数复杂度

注：erfen 指普通的二分，找不到返回-1。kind_erfen 指找到第一个大于此数的位置

#include<bits/stdc++.h>
using namespace std;
#define ull unsigned long long
int n, m;
int x, y;
bool inverted = false;
bool current = false;
ull ans;

vector<int> dataa[1000009];
vector<bool> exists[1000009];

short erfen(int val, int row){ // return -1 if not found
    int mid;
    int l = 0, r = dataa[row].size();

    while(l<r){
        mid = (l+r)>>1;
        if(dataa[row][mid] >= val){
            r = mid;
        }
        else{
            l = mid + 1;
        }
    }
    if(l >= dataa[row].size() || dataa[row][l] != val){
        return -1;
    }
    return l;
}

short kind_erfen(int val, int row){ // return value greater than
    int mid;
    int l = 0, r = dataa[row].size();

    while(l<r){
        mid = (l+r)>>1;
        if(dataa[row][mid] >= val){
            r = mid;
        }
        else{
            l = mid + 1;
        }
    }
    return l;
}


bool valid(int x, int y){
    if(x<0||y<0||x>=n||y>=n)return false;
    return true;
}

bool query(int x, int y){
    if(!valid(x, y)){
        return false;
    }
    int pos = erfen(y, x);
    if(pos == -1){
        return false;
    }
    if(exists[x][pos] == false){
        return false;
    }
    return true;
    
}

void push(int x, int y){
    short pos = kind_erfen(y, x);
    dataa[x].push_back(0);
    exists[x].push_back(false);
    for(int i = dataa[x].size()-1; i > pos ; i--){
        dataa[x][i] = dataa[x][i-1];
        exists[x][i] = exists[x][i-1];
    }
    dataa[x][pos] = y;
    exists[x][pos] = true;
}

void pop(int x, int y){
    int pos = erfen(y, x);
    exists[x][pos] = false;
}

short step[8][2] = {{1,-1},{1,0},{1,1},{0,-1},{0,1},{-1,-1},{-1,0},{-1,1}};
void contribute(int x, int y){
    for(int k=0;k<8;k++){
        x += step[k][0]; y += step[k][1];
        if(valid(x, y)){
            bool ouo = query(x, y);
            ans += (!query(x, y))*(current?-1:1) + (query(x, y))*(current?1:-1);
        }
        x -= step[k][0]; y -= step[k][1];
    }
}

void rr(int x, int y){
    if(current){
        pop(x, y);
    }
    else{
        push(x, y);
    }
    contribute(x, y);
}

inline void add(int x, int y){
    current = query(x, y);
    if(inverted && !current || !inverted && current){
        return; // No change
    }
    rr(x, y);
}

inline void remove(int x, int y){
    current = query(x, y);
    if(inverted && current || !inverted && !current){
        return; // No change
    }
    rr(x, y);
}

inline void reverse(int x, int y){
    current = query(x, y);
    rr(x, y);
}

int main(){
    cin>>n>>m;
    while(m--){
        int opt;
        cin>>opt;
        switch (opt){
            case 1:{
                cin>>x>>y;
                x--;y--;
                add(x, y);
            }break;
            case 2:{
                cin>>x>>y;
                x--;y--;
                remove(x, y);
            }break;
            case 3:{
                cin>>x>>y;
                x--;y--;
                inverted = !inverted;
                reverse(x, y);
            }break;
            case 4:{
                cout<<ans<<endl;
            }break;
            default:break;
        }
    }
    return 0;
}

J (T10)

博弈论，在 $m \geq 32$ 后开始以八行为一组循环。有一个20以后的组合比较难想，最后写了个模拟把这个爆出来了

不过多评价，这种题就要享受自己构建可行方案解题的乐趣（嗯嗯）

#include<bits/stdc++.h>
using namespace std;
#define int long long
int remainder[9] = {0, 0, 0, 4, 4, 4, 6, 7};

signed main(){
    int T;
    cin>>T;
    while(T--){
        int a;
        cin>>a;
        cout<<(remainder[a%8] + (a / 8) * 4  - 2*(a%8==7&&a>10) - (a>=30&&a%8==6))<<endl;
    }
    return 0;
}

K (T11)

从第 i 堆卡牌中进行 j 次抽取操作所贡献的能力值相当于求出从 1 到 j+1 的和并减去其中的最小值。所以我们可以预先计算出这个贡献的能力值 chooce[i][j]

从第一堆卡牌开始，考虑从第0堆到第 i 堆中抽取 card 个卡片可以取得的最大能力值 dp[i][card] 。我们在第 i 堆拿 num 个卡片，在第 0 到 i-1 堆拿 card-num 个卡片的话，所产生的能力值就为 dp[i-1][card-num] + choose[i][num]。从0到n-1动态规划，答案为 dp[n-1][...] 中的最大值

#include<bits/stdc++.h>
using namespace std;
#define int unsigned long long
int n, m, k;
int datas[300][3000];
int choose[300][3000];
int dp[300][3000];
signed main(){
    cin>>n>>m>>k;
    
    for(int i=0;i<n;i++){
        int min_val = 114514;
        int tot = 0;
        for(int j=0;j<m;j++){
            cin>>datas[i][j];
            min_val = min(datas[i][j], min_val);
            tot += datas[i][j];

            if(j>=1)
            choose[i][j] = tot - min_val;
            dp[i][j] = choose[i][j];
            if(j==m-1){
                choose[i][m] = tot;
                dp[i][m] = tot;
            }
        }
    }

    for(int i = 1; i < n;i++){
        for(int card = 0; card <= k; card ++){
            for(int num = 0; num <= card && num <= m; num ++){
                dp[i][card] = max(dp[i-1][card-num]+choose[i][num], dp[i][card]);
            }
        }
    }

    int res=0;
    for(int i=0;i<=k;i++){
        res = max(res, dp[n-1][i]);
    }
    cout<<res<<endl;
    return 0;
}

L (T12)

乍一看好像没什么头绪，我们可以一步一步分析

Step 1

如果题目的数据都是单调递增的话就很好了，所有的类型2的结果都是0。但如果数据有一段递减的段落的话，我们希望它通过最少次数的翻倍操作达成单调不递减。那么它所达成的单调不递减序列中一个元素一定在前一个元素到其两倍的范围之内，也就是说 $a_{i-1} \leq a_{i} < 2a_{i-1}$。这样的数组称为平滑的

对于一个数组 a ，我们可以事先就构建出一个描述每个元素需要乘多少次2才能让整个数组 a 平滑的数组 b，之后每次查询的时候只用把每个元素所需要的次数 b[i] 相加就可以了

翻倍操作相当于减少这个元素所需要的翻倍次数，所以就把对应的 b 减去一

这是我刚开始的想法， ~~但第二个测试数据没过（。~~ 后来发现虽然平滑的序列一定单调不递减，但单调不递减的序列不一定平滑。换句话说，我们可以用比构造平滑序列更少的次数来让序列不递减

我们会发现，一个递增的序列（也就是 b 递减）不需要参与计算。也就是说，我们要刨除序列中 b 递减的部分，只保留增长的部分。于是，我们可以从头开始记录 b[l] 到 b[i] 的最小值。用当前的 b[i] 剪掉这个最小值，得到的差累加起来就是最终的答案。图形化表示就是这样的：

我可能说的有一点绕（逃）。Anyway，在这里附上出题人 Allen 大佬更为严谨的证明过程 (=^^) /

为了方便计数，我们定义第 $i$ 个数乘2的次数为 $e_i \in \mathbb{Z}_{\geq 0}$

询问的目标是

$$ \min \sum^r_{i=l+1}e_i \quad \mathrm{s.t.} \quad a_i \times 2^{e_i} \leq a_{i+1} \times 2^{e_{i+1}} \quad (\forall i \in [l, r-1]) $$

把相邻约束用指数差线性化。定义

$$ c_i = \left\lceil \log_2 \frac{a_i}{a_{i-1}} \right\rceil \in \mathbb{Z} \quad (i \in [2, n]) $$

则

$$ a_i \times 2^{e_i} \leq a_{i+1} \times 2^{e_{i+1}} \Leftrightarrow e_{i+1} - e_i \geq c_i $$

于是目标函数可被重写为

$$ \min \sum^r_{i=l+1} e_i \quad \mathrm{s.t.} \quad e_{i+1} - e_{i} \geq c_i, \quad e_i \geq 0 $$

令前缀和

$$ b_k = \sum^k_{i=1} c_i $$

容易得到我们最后的结论

$$ \mathrm{Ans} (l, r) = \sum^r_{k=l+1} \left( b_k - \min_{t \in [l+1, k]} b_t \right) $$

（略有改动）

他的结论最小值是从 l+1 开始算，而我的是从 l 开始算。~~不过我也懒得推为什么了大概意思差不多~~

总之！ 我们现在只需要算出每个元素 $b_i$ 减去它之前元素的最小值 $\min b_k, \enspace l\leq k<i$ 的和就可以了。

Step 2

剩下的话，我开了一个线段树维护 $b$ 的从 $l$ 到 $r$ 的最小值 min，和 sumr 还有答案 summ ，类似于这样：

~~（灵魂画手）~~

最小值和总和的线段树求解比较简单就不赘述了。summ 的意思是在此区间进行查询操作 2 所返回的结果

如果它的查询区间正好和线段树的区间重合，那就很简单了，直接返回 summ ，如果没有，我们需要把这些答案累加起来，并加上一个偏移

偏移为当区间左侧的最小值是 val 的时候本区间还需要加多少操作次数，由 bias() 这个函数求出。他会找到 val 与这个区间的交点，并用 (r-l+1)*val 的长方形剪掉 summ 和 sumr 的面积（也就是蓝色和橙色的面积），从而求得图中深蓝色的 bias

查询操作或者 summ 的更新就是靠计算偏移来进行的。用左边区间的最小值给右边区间做偏移，最后汇总得到答案

求偏移的时间复杂度是一个 $\log$，再算上查询的 $\log$，总的时间复杂度为 $O(n\log^2 n)$

这道题算是这两年1024比赛最难的了（）非常考验选手对问题进行抽象概括，识别pattern，考虑边界情况，最终代码实现的能力 :spoiler[ （出题组太强了呜呜呜） ]

以及代码：

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

#define int long long
#define inf 9223372036854775807
#define ls treee[k].lson
#define rs treee[k].rson
#define mid ((l+r)>>1)
#define MAX 100009

int n,q,a[MAX];
int b[MAX];

struct node{
    int lson, rson;
    int minn, summ;
    int sumr;
}treee[2*MAX];
int ttop;


int inittree(int l, int r){
    ttop++;
    int k = ttop;
    if(l==r)return k;
    ls = inittree(l,mid);
    rs = inittree(mid+1, r);
    return k;
}


int bias(int k, int l, int r, int val){
    if(l==r){
        return (treee[k].minn >= val) ? (treee[k].minn - val) : 0;
    }
    if(treee[k].minn >= val){
        return (treee[k].sumr - treee[k].summ) - (r-l+1)*val;
    }
    if(treee[ls].minn <= val){
        int bb = bias(ls, l, mid, val);
        return bb ;
    }else{
        int aa = (treee[ls].sumr - treee[ls].summ) - (mid-l+1)*val + bias(rs, mid+1, r, val) - bias(rs, mid+1, r, treee[ls].minn);
        return aa;
    }
}

void buildtree(int k, int l, int r){
    if(l==r){
        treee[k].minn = b[l];
        treee[k].sumr = b[l];
        return;
    }
    buildtree(ls, l, mid);
    buildtree(rs, mid+1, r);
    
    treee[k].minn = min(treee[ls].minn, treee[rs].minn);
    treee[k].summ = treee[ls].summ + treee[rs].summ;
    treee[k].sumr = treee[ls].sumr + treee[rs].sumr;
    treee[k].summ += bias(rs, mid+1, r, treee[ls].minn);
}

void printtree(int k, int l, int r){
    cout<<"---"<<endl;
    cout<<k<<','<<l<<','<<r<<endl;
    cout<<treee[k].minn<<','<<treee[k].sumr<<','<<treee[k].summ<<endl;
    cout<<"---"<<endl;
    if(l!=r){
        printtree(ls, l, mid);
        printtree(rs, mid+1, r);
    }
}

void minuss(int k, int l, int r, int pos){
    if(pos < l || pos > r){
        return;
    }
    if(l==r){
        treee[k].minn--;
        treee[k].sumr--;
        return;
    }
    minuss(treee[k].lson, l, mid, pos);
    minuss(treee[k].rson, mid+1, r, pos);
    
    treee[k].minn = min(treee[ls].minn, treee[rs].minn);
    treee[k].summ = treee[ls].summ + treee[rs].summ;
    treee[k].sumr = treee[ls].sumr + treee[rs].sumr;
    treee[k].summ += bias(rs, mid+1, r, treee[ls].minn);
}

struct query_node{
    int minn, summ;
};

query_node querysum(int k, int l, int r, int ll, int rr, int bb){
    if(l > rr || r < ll){
        query_node res;
        res.minn = bb;
        res.summ = 0;
        return res;
    }
    if(l >= ll && r <= rr){
        query_node res;
        res.minn = min(bb, treee[k].minn);
        res.summ = treee[k].summ;
        if(bb != inf){
            res.summ += bias(k, l, r, bb);
        }
        return res;
    }
    query_node lres = querysum(ls, l, mid, ll, rr, bb);
    query_node rres = querysum(rs, mid+1, r, ll, rr, min(bb, lres.minn));
    query_node res;
    res.minn = min(bb, rres.minn);
    res.minn = min(res.minn, lres.minn);
    res.summ = lres.summ + rres.summ;
    return res;
}

signed main(){
    cin>>n>>q;
    inittree(1, n);
    for(int i=1;i<=n;i++){
        cin>>a[i];
    }

    b[1] = 0;
    for(int i=2;i<=n;i++){
        b[i] = b[i-1];
        if(a[i] > a[i-1]){
            int ovo = 0;
            while(a[i-1] * (1<<ovo) <= a[i]){ ovo++;}
            ovo--;
            b[i] -= ovo;
        }
        else if(a[i] < a[i-1]){
            int ovo = 0;
            while(a[i] * (1<<ovo) < a[i-1]) ovo++;
            b[i] += ovo;
        }
    }

    buildtree(1, 1, n);
    while(q--){
        int opt;
        cin>>opt;
        if(opt == 1){
            int pos;
            cin>>pos;
            minuss(1,1,n,pos);
        }else{
            int l, r;
            cin>>l>>r;
            query_node result = querysum(1,1,n,l,r,inf);
            cout<<result.summ<<endl;
        }
    }
    
    return 0;
}

从夯到拉

最近从夯到拉的排名很火，于是：

主要依据是题目的思维跳跃度/难易度，野榜，仅代表个人的偏好，不喜轻喷（

题外话

2024的Coding Challenge活到了第二天的下午，这次第一名的大佬熬到第二天凌晨6点左右就完赛了，:spoiler[快进到2026年的1024比赛开赛当天就被AK]

主播这次就比较摆了，磨蹭到结束前两个小时才写完

每次打OI竞赛的时候都很感慨自己当初为什么不在体制内继续学信息学奥赛（哭）

总之非常感谢出题组的付出，使这个活动延续下去，也提供了一个认识各位大佬的平台~

IG Chemistry(0620) 复习笔记

Mon, 15 Sep 2025 00:00:00 GMT

本文根据savemyexams, 课上的笔记和网络上的信息整理而来

虽说我尽量把我所学的所有IG化学知识都记录在此。但难免有疏漏，最好考前看一眼syllabus: here

标注为(!)的部分代表此部分笔记为课堂笔记整理而来，并没有对照savemyexams或者syllabus检查过全面性 ~~(差异有点大就以老师的为准了(逃))~~，需要读者自行验证

本文原先使用Typora撰写，其中有些拓展语法(如高亮==, 上标^, 下标~) fuwari并不支持 ~~（而我也懒得改成LaTeX了）~~ ，请见谅QAQ

所以如果有任何错误/补充欢迎评论指正

Table of Content:

1. States of Matter
- 1.1 Solids, Liquids & Gases
2. Atoms, Elements & Compounds
3. Stoichiometry
- 3.1 Formulae & Relative Masses
- 3.2 The Mole & the Avogadro Constant
4. Electrochemistry
- 4.1 Electrolysis
- 4.2 Applications of Electrolysis
  - 4.2.1 Electroplating
  - 4.2.2 Hydrogen Fuel Cells
5. Chemical Energetics
- 5.1 Exothermic & Endothermic Reactions
6. Chemical Reactions(!)
7. Acids, Bases & Salts
- 7.1 The Characteristic Properties of Acids & Bases
- 7.2 Preparation of Salts
8. The Periodic Table
- 8.1 The Periodic Table & Trends
  - 8.1.1 The Periodic Table
  - 8.1.2 Periodic Trends
- 8.2 Group Properties & Trends
9. Metals
10. Chemistry of the Environment
- 10.1 Water & Water Pollution
- 10.2 Air Quality & Climate
11. Organic Chemistry
12. Experimental Techniques & Chemical Analysis

1. States of Matter

1.1 Solids, Liquids & Gases

1.1.1 Kinetic Theory(..)

	solids	liquids	gases
Volume	fixed	fixed	not fixed
	fixed shape	adopt the shape of the container	adopt the shape of the container
	high density	middle	low density
	regular pattern	randomly arranged	randomly arranged
	vibrate around a fixed position	move around each other	move quickly and randomly in all directions
	low energy	greater energy	highest energy

1.1.2 States of Matter

two points: melting point and boiling point

boiling	evaporating
boiling point	a range of temp
bubbles below the surface	surface

range of temp: Condensation, evaporating

sublimation: only a few solids(CO2,I2)

reversible arrow: ⇌

1.1.3 Pressure & Temperature in Gases

Ideal Gas Law: $$ pV=nRT $$

1.1.4 Diffusion

==Diffusion==: Particles move down the concentration gradient (?)

温度越高，diffusion越快

random motion of particles

high concentration -> low concentration

the concentration is even as they spread out

relative molecular masses

NH3 + HCl -> NH4Cl

HCl > NH3

一些gas的论证：(vaporised 后）move randomly in the container, no forces between gaseous molecules(没有力支撑，液体就有支撑）, molecules can move apart（液体就不行）

2. Atoms, Elements & Compounds

Structure	Bonding	组成	Graph(记得label ！)
Giant Ionic	Ionic Bond	Metal + Non-metal	[ ]<sup>+</sup> [ ]<sup>-</sup> 或者正负离子交替
Giant Metallic	Metallic Bond	Metal	lattice的cations还有sea of delocalised e-
Giant Covalent	Covalent Bond	Diamond, Graphite, SiO2	一般不画
Simple Molecular	Covalent + Inter Molecular Forces	Non-metal	像文氏图,然后画电子(need = share)

Structure	Electrical Conductivity	Reason	m.p. / b.p.
Giant Ionic	l / aq (molten / aqueous state)	Mobile Ions	High (Strong ionic bond between oppositely charged ions)
Giant Metallic	s / l	Delocalised e-	High (Strong metallic bond between cations & delocalised e-)
Giant Covalent	only graphite	Delocalised e-	High (Strong covalent between atoms)
Simple Molecular	x		Low (Weak IMF between molecules)

2.1 Atomic Structure & the Periodic Table

2.1.1 Elements, Compounds & Mixtures

Element: 元素

Compound: 化合物

Mixture: 混合物

可以继续分为homogeneous mixture（质地统一） / heterogeneous mixture（不统一）

2.1.2 Atomic Structure

Subatomic particles: protons, neutrons, electrons

nucleus: 原子核

relative atomic mass: 相对原子质量

Atomic number(Z): protons

Nucleon Number / mass number (A): protons + neutrons

Atomic notation: A上Z下

2.1.3 Electronic Configuration

表示原子结构两种方式：electron shell diagrams, electronic configuration (electronic structure)

离原子核越远，电子层能量越高

the outermost shell = the valence shell最外层

period: number of notations

group: last notation

最外层电子：valency electrons

2.1.4 Isotopes

Isotopes: different atoms of the same element (that contain the same number of protons but a different number of neutrons)

表示法：C-14(mass number)

化学性质相似：相同的最外层电子

物理性质差异：不同的原子质量

2.2 Ions & Ionic Bonds

2.2.1 Ions & Ionic Bonds

Ion: An electrically charged atom or group of atoms formed by the loss or gain of electrons

负离子：anion

正离子：cation

ionic bond: strong electrostatic forces of attraction between opposite charges

dot-and-cross diagram: 元素外打括号，右上角写电荷。（只用画最外层电子）记得配平（前面写系数）

2.2.2 Ionic Bonds & Lattice Structure

lattice structure: ordered, repeating, regular arrangement of alternating anions and cations.

2.2.3 Properties of Ionic Compounds

solid at r.t.

high m.p. and b.p. (strong electrostatic forces)

good conductors of electricity in the molten state or in solution

poor conductors in the solid state

2.3 Simple Molecules & Covalent Bonds

2.3.1 Covalent Bonds

Covalent bond: pairs of electrons are shared between atoms(只有non-metal elements)

Molecules: two or more atoms are covalently bonded together

画dot-and-cross diagram: 两个圆相交部分画电子

single covalent bond(single bond)只share一对电子

2.3.2 Molecules & Compounds

double bond / triple bound

2.3.3 Properties of Simple Molecular Compounds

Simple molecular compound: just a few atoms covalently bonded together

low m.p. and b.p. (如果分子更大m.p.和b.p.也更大) (因为week intermolecular forces弱分子间作用力)

poor electrical conductivity(no free ions or electrons)(可作为insulator)

2.4 Giant Structures

Diamond & Graphite(石墨)

Allotropes(同素异形体): Different atomic or molecular arrangements of the same element in the same physical state

Diamond: 接四个 form a tetrahedron(四面体)

no intermolecular forces

Graphite: 接三个 form layers of hexagons

layer之间：weak intermolecular forces

unpaired electron becomes delocalised

Properties & Uses

Diamond:

don't conduct electricity

high m.p.

extremely hard and dense

uses: jewellery, cutting tools

Graphite: can conduct electricity, slippery and smooth, high m.p.

pencil

industrial lubricant(润滑剂)

non-reactive electrods for electrolysis(conduct electricity, high m.p., inert(stable), cheap)

2.4.2 Silicon(IV) Oxide

Quartz: 石英

结构：钻石的结构。碳变为硅，键上面放一个氧

性质：类似于钻石，更便宜

用途：sandpaper,

2.4.3 Metallic Bonding

metallic lattice

electrons delocalised

sea of electrons

Properties:

high m.p. and b.p.

conduct electricity

malleable(可塑性)

Ductile(可延展性)

(layers of positive ions can slide over one another and take up different positions)

wire

3. Stoichiometry

(化学计量法)

Solid: $n=\frac{m}{Mr}$ (m单位g , Mr单位g mol-1)

Liquid: $n = c \times V$ (c单位mol dm-3 , V单位dm3)

Gas: $n=\frac{V}{24}$(V单位dm3, 24单位dm3 mol-1)

3.1 Formulae & Relative Masses

3.1.1 Formulae

diatomic molecules: 双原子分子

3.1.2 Empirical Formulae & Formulae of Ionic Compounds

Empirical formula: 实验式

polyatomic: 多原子的

3.1.3 Writing Equations

reactants: 反应物

products: 生成物

Solid = (s)
Liquid = (l)
Gas = (g)
Aqueous = (aq)

Precipitates: 沉淀

3.1.4 Ar & Mr

Ar: relative atomic mass

Mr: relative molecular mass

(对于ionic compound是relative formula mass)

3.2 The Mole & the Avogadro Constant

3.2.1 The Mole

The mole: the SI unit of amount of substance

Avogadro Constant: 6.02e23

molar mass: 一摩尔的物质的质量(gram)在数值上等于相对质量

Avogadro's Law: same temperature and pressure, 相同数量气体占的空气相等

常温常压1mol气体占24dm3 / 24000cm3空间(molar gas volume at RTP)

3.2.2 Linking Moles, Mass & Mr

n = m / Mr

3.2.3 Reacting Masses

limiting reactant: the reactant that is used up first

excess reactant: the one that is remaining

3.2.4 Calculating Concentration

Solute(溶质): a solid substance that dissolves into a liquid

Solvent(溶剂): the liquid that a solute dissolves in

concentration: the amount of solute there is in a specific volume of the solvent(g/dm3 & mol/dm3)

3.2.5 Titration Calculations

3.2.6 Empirical & Molecular Formula

Hydrated salt: a crystallised salt that contains water molecules as part of its structure

3.2.7 Percentage Yield & Purity

Yield: the term used to describe the amount of product you get from a reaction

percentage yield = actual yield / theoretical yield

percentage composition:

Percentage purity

4. Electrochemistry

4.1 Electrolysis

==Electrolysis==: Break down ionic compounds in molten / aqueous state by electricity

4.1.1 Electrolysis Principles

molten / aqueous

ionic compounds

electrode: a rod of metal(platinum) or graphite through which an electric current flows into or out of an electrolyte (conductor, inert)

electrolyte: the ionic compound in a molten or dissolved solution that conducts the electricity

-> Molten Salt

-> Conc / dilute solution

-> Copper electrodes

anode: the positive electrode of an electrolysis cell

anion: negatively charged ion

cathode: the negative electrode of an electrolysis cell

cation: positively charged ion

anode: non-metals (在没有conc的情況oh先氧化，否则halogen先)

cathode: hydrogen / metal

PANIC(Positive is Anode Negative Is Cathode)

AN OX / RED CAT (Anode Oxidation / Reduction Cathode)

Shiny: Nickel, chromium

4.1.2 Electrolysis of Molten Compounds

binary ionic compound: consisting of just two elements joined together by ionic bonding

4.1.3 Electrolysis of Aqueous Sodium Chloride & Dilute Sulfuric Acid

brine: concentrated solution of aqueous sodium chloride

gas test for chlorine: if damp litmus paper is dipped into a sample of the gas, it will turn red and then bleach to a white colour

4.1.4 Electrolysis of Aqueous Solutions

ammeter: 电流表

两个电极都是铜，液体是硫酸铜：硫酸铜浓度不变，电极质量变化

4.1.5 Ionic Half Equations

Oxidation: loss of electrons

Reduction: gain of electrons

4OH- -> O2 + 2H2O + 4e-

OIL RIG(Oxidation Is Loss, Reduction Is Gain)

RED CAT(Reduction at the Cathode)

AN OX(Anode for Oxidation)

4.2 Applications of Electrolysis

4.2.1 Electroplating

Electroplating: the surface of one metal is coated with a layer of a different metal

cathode: object to be electroplated

anode: made from the pure metal that will be plated onto the object

Reason: make metals more resistant to corrosion or damage

4.2.2 Hydrogen Fuel Cells

fuel: a substance which releases energy when burned

Advantages:

Renewable, no pollution, release more energy per kg, no power is lost in transmission, quieter

Disadvantages:

expensive, hydrogen is more difficult and expensive to store compared to petrol(flammable and easily explodes when under pressure), affected by low temp

5. Chemical Energetics

5.1 Exothermic & Endothermic Reactions

5.1.1 Endothermic & Exothermic Reactions

system: the reacting chemicals

surroundings: anything other than the reacting chemicals

和acid反应，carbonate可以是exo或者endo，metal只能exo

Exothermic Reaction: 放热

==Definition==: An exothermic reaction transfers thermal energy to the surroundings leading to an increase in the temperature of the surroundings.

e.g.: Neutralization, oxidation, combustion(燃烧反应), dissolving anhydrous salts, reaction between acids and metal carbonates, dissolving crystalline salts(？)

application: hand warmers, self-heating cans

\Delta H < 0

Endothermic Reaction: 吸热

==Definition==: An endothermic reaction takes in thermal energy from the surroundings leading to a decrease in the temperature of the surroundings.

e.g.: Atomization(变成原子？), Electrolysis, thermal decomposition, the first stage of photosynthesis(光合作用),

Application: cold packs

\Delta H > 0

Reaction pathway diagram(reaction profiles)

peak: transition state / activated complex

5.1.2 Enthalpy Change & Activation Energy

原子或分子想要反应要撞在一起。影响因素有能量，方向，频率...

Definitions

Enthalpy(H)(kJ/mol): an indication of the total energy of a substance and it cannot be measured directly.

==Enthalpy change== of a reaction($\Delta H$): The transfer of thermal energy during a reaction.

$\Delta H$ is negative for exothermic reactions and positive for endothermic reactions. $$ \Delta H = \Sigma H(products) - \Sigma H(reactants) $$ *Energetic stability of a system

Exothermic reactions are more energetically favorable(likely to happen) than endothermic ones because a system with lower energy content is more stable.

Lower energy state -> more stable

Standard enthalpy changes

Standard enthalpy changes: $\Delta H °$

Standard condition(°-结合在一起): To make comparison of enthalpy changes a fair comparison, same conditions must be used.

Pressure: 101kPa

Temperature: 298K

Concentration of solutions: 1.0 mol / dm3

Normal physical state

Allotropes: 选更energetically stable的 (选石墨不选钻石)

Activation Energy

==Definition==: The minimum energy that colliding particles must have to react

E~A(forward)~：从reactants到顶峰的能量

E~A(reverse)~：从products到顶峰的能量

5.1.3 Bond Breaking & Bond Forming

Bond Energy(Bond enthalpy): Energy required to break a mole of (covalent) bonds in the gaseous state. (always positive($\Delta H > 0$))

有些bond energy是确定的有些取平均（被其他原子的存在所一项

breaking bonds: needs energy (endothermic)

forming bonds: releases energy (exothermic)

Bond breaking:

the energy needed to break bonds

Energy change = Energy required to break bonds - Energy given out when bonds are made(左边减去右边)

6. Chemical Reactions(!)

6.1 Chemical Change & Rate of Reaction

6.1.1 Physical & Chemical Changes

Physical changes: Changes in which new chemical substances are not produced

e.g. change in states, separation of mixtures ...

Chemical changes: changes in which new chemical substances are produced

e.g. Decomposition, electrolysis, respiration, photosynthesis, polymerisation, combustion, etc.

6.1.2 Rates of Reaction Factors

study of chemical reactions -> reaction kinetics

Rate of reaction

Rate = change in amount of reactants or product / time

Unit: mol dm^-3^ s^-1^ / mol dm^-3^ min^-1^ / mol dm^-3^ h^-1^

change in amount

-> volume of gas

-> concentration of reactants or products

Measuring rate of reaction

Acidity:

Volume:

Mass:

Appearance:

Electrical conductivity:

Calculation of the rate of reaction

gradient / tangent line

rate of reaction = d[reactant或者product] / dt

reactant的话要取负的gradient

6.1.3 Collision Theory

Heterogeneous reactions: 不同phase之间的物质的reaction

Reaction:

-> particles must collide

-> in the correct orientation and with sufficient energy

Activation Energy: The minimum energy required for a reaction to occur (E~A~)

Ineffective Collision: takes place if the colliding particles do not have enough energy to react (low K.E.)

Effective(successful) Collision: takes place if the colliding particles do have enough energy to react (high K.E.)

sme上的定义(?): A successful collision is where the particles in the reactant(s) are rearranged to form the products

Speeding up a reaction -> increase rate -> increase effective collision -> (breakpoint) increase collision frequency -> Concentration / Pressure / Surface Area / Temperature

(breakpoint) increase # of particles with E > E~A~ -> Temperature / Catalyst

Energy of molecules -> directly proportional to their absolute temperature

distribution of energies between different molecules: Boltzmann distribution (not all of the particles have the same amount of k.e. )

(一个横轴molecular energy 纵轴number of molecules的图。在竖线E~A~右边的部分可以参与反应)

-> The distribution always goes through the origin

-> The curve approaches the x-axis but does not touch it

-> The peak represents the most probable energy.

-> The area under the curve represents the total number of particles.

-> The shaded portion represents the number of particles with energy higher than or equal to the activation energy (E>=E~A~)

The Effect of Concentration and Pressure

frequency of collisions 正相关

不改变Boltzmann distribution of energies

The Effect of Surface Area

和Frequency of Collisions 正相关

不改变Boltzmann Distribution of Energies

The Effect of Temperature

-> 改变Temperature -> 改变particles的K.E. -> 改变速度快慢 -> 改变 Collision Frequency

-> 增加或减少有E大于等于E~A~的particles

-> 总结：改变frequency of effective collisions

温度增加：most probable energy更高，但更少的粒子达到了这个要求

反之亦然

Rate翻倍只要Temp加十就好了（有点像dB+3

temp可以影响reactants的初始enthalpy(在endo exo那个图里面上移下移)

The Effect of Catalyst

Catalyst: increases(?) the rate of reaction by providing an alternative reaction path way with lower E~A~

How: more particles have E>=E~A~, so increase in frequency of effective collisions

催化剂的化学性质反应前后不改变

在Boltzmann图面就是E~A~往左移，在endo exo的图里就是peak向下移

6.1.4 Explaining Rates Using Collision Theory

6.1.5 Investigating The Rate of a Reaction

6.1.6 Interpreting Data

6.2 Reversible Reactions & Equilibrium

==Equilibrium==: The rate of the forward reaction is equal to the rate of the reverse reaction + the concentrations of reactants and products are no longer changing

reversible reaction: one which can proceed in both directions, as indicated by the "你知道是啥" sign

re-form

equilibrium mixture (in balance)

Dynamic Equilibrium: Rates of forward and reverse reactions are equal in a closed system. (No net change in concentration of reactants and products. (constant concentration))

Equilibrium position: the relative amount of products and reactions present in an equilibrium mixture (mixture of reactants and products)

Le Chatelier's Principle: If a change is made to a system at dynamic equilibrium, the position of equilibrium moves to minimise this change.

-> 增减一个反应物会反作用（syllabus上说的是改变concentration，也就是说加pure solid和pure liquid也不会改变平衡位置(bestchoice)。存疑）

-> pressure: 会影响气体，看反应物和生成物的摩尔数。会倾向于操作的相反

-> temperature: 看是exo还是endo。倾向于操作的相反

-> catalyst: 不影响equilibrium, 加速到达equilibrium的速度

shift equilibrium to the left / right

Haber process - Ammonia Production: N~2~(g) + 3H~2~(g) <-> 2NH~3~(g); ΔHr = -92 kJmol^-1^

Factors	Equilibrium Aspects	Industrial Aspects
Temperature	Low	450 C
Pressure	High	200 atm
Concentration(NH3)	Removal of NH3	Liquify NH3
Catalyst	Yes	Iron(Fe)

N2: Fractional distillation of liquid air

H2: CH4(methane) + H2O(g) -> 3H2 + CO

450: Compensate temperature (太低：increase in yield, low rate of reaction(低KE，低frequency))

200: Compensate Pressure (太高：increase in yield, increase in operating cost / expensive)

Contact process - sulfuric acid production

-> S + O2 -> SO2 (buring sulfur or roasting sulfide ores)

-> 2SO~2~(g) + O~2~(g) <-> 2SO~3~(g) (竟然是reversible的，必须制裁！)

-> SO3 + H2O -> H2SO4 (* SO3 + H2SO4 -> H2S2O7 ; H2S2O7 + H2O -> 2H2SO4)

Factors	Equilibrium Aspects	Industrial Aspects
Temperature	Low	450 C
Pressure	High	2 atm
Concentration	Removal of SO3	Absorbed by conc. H2SO4
Catalyst	Yes	Vanadium Oxide, V2O5

为什么Temperature和Pressure的值都不太低/高呢？和haber process的原因一样。需要compensate

Factors:

6.2.1 Reversible Reactions

6.2.2 Equilibrium

6.2.3 The Haber Process

6.2.4 The Contact Process

6.3 Redox(!)

==Disproportionation== : a redox reaction in which both oxidation and reduction occurs on the same atom(it is simultaneously oxidised and reduced)

O不是-2的特例：F2O (+2), H2O2 (-1)

H不是+1的特例：和某个金属结合(metal hydride) NaH

Formula	Common Name	Name
NO~3~^-^	Nitrate ion	Nitrate ion
NO~2~^-^	Nitrite ion	Nitrate ion
NO~2~	Nitrogen dioxide	Nitrogen (IV)
SO~4~^2-^	Sulfate ion	Sulfate (VI)
SO~3~^2-^	Sulfite ion	Sulfate (IV)
SO~2~	Sulfur dioxide
SO~3~	Sulfur trioxide

MnO4- : manganate(VII)

6.3.1 Oxidation & Reduction

Roman numeral: 用来indicate the oxidation number of an element in a compound

定义表

Redox reactions: involving simultaneous oxidation and reduction / involving gain and loss of electrons

==Oxidation==: gain of oxygen / loss of electrons / an increase in oxidation number

==Reduction==: loss of oxygen / gain of electrons / a decrease in oxidation number

identify redox reactions by changes in oxidation number ...

Oxidation number: a number assigned to an atom or ion in a compound, showing the number of electrons that an atom

6.3.2 Redox & Electron Transfer

==Oxidising agent==: A substance that oxidises another substance and is itself reduced

Very powerful: Acidified Potassium Manganate(VII): KMnO~4~

MnO4- + 8H+ + 5e- -> Mn2+ + 4H2O

pink -> colourless(?)

==Reducing agent==: A substance that reduces another substance and is itself oxidised

Very powerful: Potassium Iodide:

2I- -> I2 + 2e-

colourless -> brown(?)

加starch变深蓝

7. Acids, Bases & Salts

ethanoic acid: 乙酸

ethanoate: 乙酸根（比如Magnesium Ethanoate)

7.1 The Characteristic Properties of Acids & Bases

base是碱，alkali是可溶解于水的碱

7.1.1 Properties of Acids & Bases

Acids

pH<7

sour taste

corrosive

Reactivity series: K,Na,Ca,Mg,Al,(C),Zn,Fe,Sn(Tin),Pb,(H),Cu,Ag,Au,Pt

Acid + Metal -> Salt + Hydrogen(置换)

acid + base -> salt + H2O(neutralisation)

acid + metal carbonate -> salt + CO2 + H2O

indicators(酸碱指示剂)

Indicator	Colour in acid	Colour in alkali
Litmus(石蕊)	red	blue
Thymolphthalein	colourless	blue
Methyl orange(甲基橙)	red	yellow

Synthetic indicators: titration(sharp change of colour)

Bases & Alkalis

==base==: Proton acceptor(?)

==alkali==: soluble base

pH>7

Bases are usually oxides or hydroxides of metals

Ammonium salt + alkali -> salt + H2O + NH3

(用于检测ammonium ion，followed by 氨气的检测(damp潮湿的 red litmus paper turns blue))

7.1.2 The Ions in Acids & Alkalis

pH scale: how acidic or alkaline a solution is

acidity, neutrality, alkalinity

logarithmic对数的

pH(n) -> 氢离子浓度为10^(-n) mol/L

universal indicator: 不同指示剂的混合物。

7.1.3 Proton Transfer, Strong & Weak Acids

H+: proton(氕)

Acids: proton donors

Bases: proton acceptors

strong & weak acids: completely / partially dissociate(ionise)

7.1.4 Classifying Oxides

acidic oxide / basic oxide

酸性氧化物和碱反应。反之亦然

neutral oxide(CO,NO,N2O)

Amphoteric oxide(ZnO, Al2O3)

7.2 Preparation of Salts

7.2.1 Preparing Soluble Salts

sulphate硫酸盐，chloride氯化物

filtrate: 过滤后的液体

Insoluble base: Dissolving

use spatula to add excess CuCO3 into a beaker of HCL until no further bubbling or no further dissolving

filter off the excess solid(取filtrate)

heat the salt solution to evaporate water

cool the saturated solution to form crystal

wash the crystal with distilled water

dry the crystal with filter paper

Soluble base: Titration

记得看syllabus!!

-> Add alkali + indicator to conical flask using a pipette

-> Add acid to burette, noting the starting volume

-> add acid to alkali slowly until indicator changes colour

-> calculate

Use volumetric pipette to transfer 25cm3 of HCl(aq) into a conical flask

Add a few drops of methyl orange indicator

fill a burette with NaOH(aq)

add NaOH(aq) from the burette to the conical flask until the end point - Orange

repeat the process without indicator, but using the same volume of acid and alkali as used in the titration

heat the salt solution to evaporate water

cool the saturated solution to form crystal

wash the crystal with distilled water

dry the crystal with filter paper

7.2.2 Preparing Insoluble Salts

precipitation reaction

the reactants must be soluble

mix AgNO3(aq) and NaCl(aq) solution in a beaker

filter the solution to collect the insoluble salt

wash the crystal with distilled water

dry the crystal with filter paper

7.2.3 Solubility Rules

Soluble: K, Na, NH4

Soluble: NO3(硝酸)(Nitrate)

Cl(默认可溶): Ag,Pb ,Hg

SO4(默认可溶): Ba, Ca, Pb , Ra, Sr

CO3(默认不可溶): 除了钾钠氨

OH(默认不可溶): 除了钾钠氨，Ca(partially), Ba

默认不可溶: OH(CaOH partially soluble,Ba(OH)2), CO3

heat transfer: particle to particle transfer

描述粒子运动：先random

7.2.4 Hydrated & Anhydrous Salts

Hydrated salts: salts that contain water within their structure

Anhydrous sats: contain no water in their structure

dehydrated: 脱水

Water of crystallisation: water molecules included in the structure of some salts during the crystallisation process

Color change:

第一主族和第二主族没什么颜色。要记得color change两个：copper sulfate 蓝色到白色；cobalt(II) chloride 粉色到蓝色

8. The Periodic Table

8.1 The Periodic Table & Trends

8.1.1 The Periodic Table

order: Increasing atomic number

group: 族

period: 周期(electron shells)

group 0第八组

Valency

Valency(combining power): how many bonds an atom can make with another atom or how many electrons its atoms lose, gain or share, to form a compound(化合价)

8.1.2 Periodic Trends

The metallic character左下最强，右上最弱

metalloids / semi-metals(准金属): shows some of the properties of metals and some of non-metals

transition elements are denser than group I elements

8.2 Group Properties & Trends

8.2.1 Group I Properties

(alkali metals)

soft and easy to cut

shiny silvery surfaces

conduct heat and electricity

low m.p. and low density (越往下m.p.越低)

8.2.2 Group VII Properties

(halogens)

poisonous

diatomic

halide ions

Cl2(Chlorine): pale yellow-green gas

Br2(Bromine): red-brown liquid

I2(iodine): grey-black solid

the outer electrons are closer to the nucleus so there are stronger electrostatic forces of attraction

越往下颜色越深

8.2.3 Group VII Displacement Reactions

halogen displacement reaction

I2 vapour: purple

I2 aqueous: brown

8.2.4 Transition Elements

hard and strong

good conductors of heat and electricity

high m.p. highly dense

form coloured compounds and often have more than one oxidation state(pigments颜料)

catalysts催化剂

limb and joint replacement

dyes and paints, stained glass jewellery

8.2.5 Noble Gases

Group 0

low m.p. and b.p.

monoatomic, colourless gasses

full outer shells

extremely stable (unreactive and inert)

9. Metals

9.1 Properties, Uses & Alloys of Metals

9.1.1 Properties of Metals

半金属：semimetals, metalloids

metal bond的强度可以由沸点得出（气体时原子都分开）

Properties of metals

conduct heat and electricity(sea of delocalized electrons)
malleable(can be hammered and made into different shapes压扁成一片) and ductile(can be drawn into wires(延展性))
lustrous & shiny
high density, high m.p. (metallic bond -determined by-> number of delocalized electrons)
form positive ions, basic oxides
solid(except mercury)

Properties of non-metal

Do not conduct heat and electricity(insulator)
brittle(脆) when solid
dull and nonreflective
low density and low m.p. (low的都是simple molecules. Giant covalent molecules还是很强的(diamond~3200, graphite~3400, silicon dioxide~2000))(看到3000优先想钻石石墨)
form negative ions, acidic oxides
solid, liquid(Br2...), gas

金属+冷水 -> 金属氢氧化物 + 氢气

金属+蒸汽 -> 金属氧化物 + 氢气

和酸：置换反应

和氧气：氧化物

9.1.2 Uses of Metals(Al, Cu)

Uses of Al:

(most abundance)(form a layer of aluminium oxide, which acts as a protective layer)

Use	Most Important Property
Aircrafts bodies	High strength-to-weight ratio, Low density
Overhead power cables	Good conductor of electricity, Low density
Saucepans	Good conductor of heat
Food containers	Non-toxic, Resistant to corrosion and acidic food stuffs
Window frames	Resistant to corrosion

Uses of Cu:

Use	Most Important Property
Electrical wires	Good conductor of electricity, High ductility
Water pipes	Easy to bend, Non-toxic, Unreactive

9.1.3 Alloys(合金)

Alloys: mixture of metal with other elements

Alloy	Components	Use	Reason 4 Use
Brass	Cu+Zn	Musical instruments, Ornaments(饰品), Door knobs	Hard, Malleable
Stainless steel	Fe+Others(Cr, Ni, C)	Cutlery(切具)	Hard, Resistant to corrosion

Cr可以让成品更shiny, 好看

Alloys通常harder, stronger, more useful, resistant to corrosion / extreme temperatures

Structure

Metal: regular arrangement of ions

Alloys: irregular arrangement of atoms

The metal lattice structure is distorted(扭曲) in alloys

Reason 4 the Properties

atoms of different sizes -> distorts the normally regular arrangements of atoms in metals -> more difficult for the layers to slide over each other -> harder / stronger

9.2 Reactivity Series & Corrosion of Metals

9.2.1 Reactivity Series

方法：displacement reactions(substitution)

K,Na,Ca,Mg,Al,(C),Zn,Fe,(H),Cu,Hg,Ag,Pt,Au

钾钠钙(钙钠)镁铝

(碳)锌铁(氢)

铜汞银铂金

四种金属反应

Metal + Acid -> Salt + Hydrogen：氢之前

Metal+ Water-> Hydroxide + Hydrogen：钾钠钙

Metal + Steam -> Oxide + Hydrogen：氢之前

Metal + Oxygen -> Oxide：氢之前+铜

CuO：黑的

9.2.2 Explaining Reactivity

Al: a protective layer of aluminium oxide which is very thin (prevents reaction with water and dilute acids)

9.2.3 Rusting of Iron

Rusting: Iron专属 Corrosion: 所有metal都有

iron + water + oxygen -> hydrated iron(III) oxide(氧化铁)

防止生锈：barrier methods, painting, plastic coating(还有后面的两个)

grease: oil

paint: plastic

iron & steel: rust

other metal: corroded

9.2.4 Galvanising & Sacrificial(牺牲) Protection

Sacrificial protection: a more reactive metal can be attached to a less reactive metal

zinc is sacrificed to protect the steel

electrons travel from the zinc to th

galvanising(镀锌): a process where the iron to be protected is coated with a layer of zinc

9.3 Extraction of Metals

9.3.1 Extraction of Metals

Metal ore: a rock that contains enough of the metal to make it worthwhile extracting

Methods:

Electrolysis aqueous solutions containing their ions
using blast furnace / react with more reactive material
碳之下：和碳或一氧化碳还原
碳之上：电解熔融氧化物/氯化物 (贵)

Reduction: 很多矿石是氧化物。移除氧是还原反应

Native metals: gold, platinum(chemical stability, 不用提取)

9.3.2 Extraction of Iron from Hematite(赤铁矿)

Ores: Hematite(Fe2O3), Magnetite(Fe3O4), Fayalite (Fe2SiO4)

blast furnace

coke(C), hematite(Fe2O3, SiO2), limestone(CaCO3)

burning of carbon to provide heat and produce CO2(Waste) C+O2 -> CO2 (exothermic)
Reaction of carbon dioxide to carbon monoxide C+CO2 -> 2CO (Good reducing agent)
Reduction of iron(III) oxide by carbon monoxide Fe2O3 + 3CO -> Fe(l) + 3CO2
Thermal decomposition of calcium carbonate / limestone to produce calcium oxide CaCO3 -> CaO(s)+CO2
Formation of slag(不要的那些impurities) CaO + SiO2(s) -> CaSiO3(l)

Slag比Iron轻

写方程式记得铁和slag是liquid, CaO是solid

9.3.3 Extraction of Aluminium from Bauxite(!)

Al2O3

Electrolysis

(~2000°C)Molten aluminium oxide (impure) / bauxite + cryolite

2000°C加了cryolite降到1000°C

Cryolite可以1. 增加导电性 2. 降低操作时的温度

电极用石墨

Cathode: Al3+ + 3e- -> Al(在cell底部(siphoned(虹吸) off from time to time))

Anode: 2O2- -> O2 + 4e- (need to be regularly replaced (reacts with oxygen))

贵->用很多电

10. Chemistry of the Environment

Simon 学案

10.1 Water & Water Pollution

10.1.1 Water: Chemical Tests

10.1.2 Substances in Water from Natural Sources

10.1.3 Water Treatment

10.1.4 Fertilisers

10.2 Air Quality & Climate

10.2.1 Air

10.2.2 Effects of Greenhouse Gases

10.2.3 Reducing the Effects of Environmental Issues

10.2.4 Photosynthesis

11. Organic Chemistry

Organic Chemistry: The scientific study of the structure, properties, and reactions of organic compounds.

(老师ppt上): the study of structure, properties, composition, reactions, and preparation of carbon-containing compounds. (excluding simple compounds like CO, CO~2~, CO~3~^2-^)

Most organic compounds contain carbon and hydrogen m but they may also include any number of other elements, such as nitrogen, oxygen, halogens, phosphorus, silicon, and sulfur

11.1 Formulae, Functional Groups & Terminology

11.1.1 Organic Formulae

Organic compounds: those which contain carbon (不包括metal carbonates, carbon dioxide and carbon monoxide)

Hydrocarbon: a compound that contains only hydrogen and carbon atoms

表示方法：empirical formula, displayed formulae, general formulae, structural formulae

Empirical Formula(C2H5): simplest ratio of atoms

Molecular Formula(C4H10): Actual number of atoms of each element in a compound

Displayed Formulae(a diagram): shows the spatial arrangement of all the atoms and bonds in a molecule

**Structural Formulae(CH3CH2CH2CH3): **shows the order and arrangement of atoms

only show important bonds(double and triple bonds)
identical groups / side groups: 打括号

*Skeletal Formula: All C, H and C-H bonds are removed

structure isomers: same molecular formulae, different structural formulae (structural isomerism)

如果是C~n~H~2n~考虑两种情况，double bond 或者 ring !!!!!

carbon: can form 4 bonds

11.1.2 Homologous Series

Functional Group: an atom or group of atoms which are bonded in a specific arrangement that is responsible for the characteristic reactions of each member of a homologous series.

-> dictates their physical and chemical properties

Homologous Series: a family of organic compounds that have similar features and chemical properties due to them have the same functional group

-> same functional group

-> same general formula

-> similar chemical properties

-> gradual change in physical properties

-> differing form one member to the next by a -CH~2~- unit

Family(Homologous Series)	中文	Functional Group	Suffix/Preffix	General Formulae	Example
Alkane	烷	C-C	-ane	C~n~H~2n+2~	Methane
Alkene	烯	C=C	-ene	C~n~H~2n~	Ethene
Alkyne	炔	C≡C	-yne	C~n~H~2n-2~	Ethyne
Halogenoalkane		-X	halo- (fluoro-, chloro-, bromo- )	C~n~H~2n+1~X	Fluoromethane
Alcohol	醇	-OH	-(an)ol	C~n~H~2n+1~OH	methanol
Carboxylic Acid		-COOH	-(an)oic acid	C~n~H~2n+1~COOH	methanoic acid
Ester		-COO-	-yl-anoate		methyl methanoate

General Formula: A type of empirical formula that represents the composition of any member of a whole homologous series of organic compound

General Characteristic of Homologous Series:

-> The same general formulae

-> same functional group

-> similar chemical properties

-> Gradation in their physical properties

-> The difference in the molecular formula between one member and the next is CH~2~

Meth, Eth, Prop, But (Monkeys Eat Peeled Bananas)

11.1.3 Saturated & Unsaturated Compounds

Saturated compounds: have molecules in which all carbon-carbon bonds are single bonds (e.g. alkanes)

Unsaturated compounds: consist of molecules in which one or more carbon-carbon bonds are not single bonds (e.g. alkenes, carboxylic acid)

11.1.4 Naming Organic Compounds(!)

Substituents: 替换掉有机物里的氢的东西（比如CH4去掉一个H加一个F）

IUPAC: International Union of Pure and Applied Chemistry

IUPAC naming system: Prefix - Parent - Suffix

-> Prefix: Name and position of substituents

-> Parent: Length of the longest carbon chain

-> Suffix: Main functional group

两个部分：the stem, end part (prefix, suffix)

The stem: indicates the number of carbon atoms present in the longest continuous chain of the compound

# of C in the longest chain	The stem
1	meth
2	eth
3	prop
4	but(u读you的音)
5	pent
6	hex
7	hept
8	oct
9	non
10	dec
11	undec
12	dodec

Substituent

Alkyl Group	Structural Formula	Name
-CH3	-CH3	Methyl
-C2H5	-CH2CH3	Ethyl
-C3H7	-CH2CH2CH3	Propyl
-C4H9	-CH2CH2CH2CH3	Butyl

# of substituents	Name
1	Mono
2	Di
3	Tri
4	Tetra
5	Penta

例子： 2-methylbutane 2,3-dimethylbutane

The end part: tells you what functional group is in the compound

End part of the name	Functional group	Organic family
ane	none (contains only C-C bonds)	Alkane
ene	C=C bond	Alkene
anol	–OH	Alcohol
anoic acid	–COOH	Carboxylic acid
amine	–NH2	Amine
-yl -anoate	–COO–	Ester

butanoic acid

propene

pentanol

高级命名法

需要指定functional group出现在哪一个carbon atom 上面（数字越小越好）

-an: 单键 -en: 双键

在propene之后，要指定双键出现在哪里（e.g. but-1-ene, but-2-ene)

-OH: alcohol / hydroxyl group

和ene一样，在ethanol之后要指定在哪（e.g. propan-1-ol, propan-2-ol)

carboxylic acid很伟大，不用指定。默认出现在1号位

Ester: 基于原先的alcohol和carboxylic acid，比较复杂，和structure的画法相反

原子越多燃烧放出的re'liang

11.2 Organic Families(!)

11.2.1 Fossil Fuels

Fossil fuels: release a large amount of energy when burned

三大类：Coal / Natural Gas(主要是CH4) / Petroleum (mixture of hydrocarbons)

petroleum的分离方式：fractional distillation

气体从塔下面被heater加热后，顺着塔向上走

塔从下往上的趋势：

-> lower boiling point

-> decreasing chain length

-> higher volatility (挥发性)

-> lower viscosity (流动性)

Temp	Name	Use
20	Refinery Gas	for gas used in heating and cooking
40	Gasoline	for fuel used in cars
110	Naphtha(石脑油)	as chemical feedstock
180	Kerosene / Paraffin(煤油)	for jet fuel
260	Diesel oil / Gas oil(柴油)	for fuel used in diesel engines
280	Fuel oil	for fuel used in ships and home heating systems
300	Lubricating oil	for lubricants, waxes and polishes
340	Bitumen(沥青)	for making roads

11.2.2 Alkanes(烷烃)

saturated hydrocarbons

C~n~H~2n+2~

cycloalkanes会少两个H

物理性质：

b.p.和m.p.：

-> 分子越大bpmp越大

-> chain越straight(没什么branches)bpmp越大

Solubility:

-> Insoluble

化学性质：

Unreactive

-> C and H have similar electronegativities

-> strong and non-polar C-C and C-H bonds

想要react的话也有

-> Combustion（燃烧）: Carbon dioxide / monoxide

Reagents 1: Excess O~2~ (Complete combustion)（reagent：和reactant差不多，是加入到原本物质的一方）

Reagents 2: Limited O2 (Incomplete combustion) (就是氧气没那么足)

Conditions: Room temperature

Equation 1: C~x~H~y~ + O~2~ ---> x CO~2~ + y H~2~O (O~2~要配平) (Complete, 燃烧产生CO~2~)

Equation 2: C~x~H~y~ + O~2~ ---> x ==CO== + y H~2~O (O~2~要配平) (Incomplete, 燃烧产生CO)

-> Substitution（比如一个H变成Cl） : Halogenoalkanes

reactions in which one atom or group of atoms is replaced by another atom or group of atoms

具体来说，这里的substitution是==halogenation== (把一个东西换成halogen)

Reagents: Halogens(Cl~2~ , Br~2~ ...)

Conditions: ==Ultraviolet light==

Equation: CH~4~ + Cl~2~ --(UV light)--> CH~3~Cl + HCl (把一个H换成Cl) (CH~3~Cl: ==Chloromethane==)

(有UV light参与所以也是photochemical reaction)

-> Cracking （断键） : Alkenes + Alkanes or Hydrogen

High temp. & press. (or catalyst + heat)

11.2.3 Alkenes(!!)

11.2.4 Addition Reactions(!!)

11.2.5 Alcohols

Alcohol: One or more H atoms in an alkane have been replaced by OH groups

General formula: C~n~H~2n+1~OH

Physical properties:

-> soluble in water

-> High boiling point (78 for ethanol)

Usage:

-> solvent

-> Fuel

Reactions:

Alkenes --(Catalytic Addition of H~2~O(g))--> Alcohols

Glucose --(Fermentation)--> Alcohols

Alcohols --> Combustion (CO~2~/CO) / Oxidation(Carboxylic acids) / Esterification(Esters)

Forming

-> Hydration

CH~2~=CH~2~ + H~2~O(steam, g) --(H~3~PO~4~ ， 300C, 60atm) --> CH~3~CH~2~OH

High Purity, High yield, Non-renewable, Continuous flow process, one product formed

High energy cost

-> Fermentation

C~6~H~12~O~6~(Glucose) --(Yeast, 25C~35C) --> 2C~2~H~5~OH + 2CO~2~

High alcohol kills the yeast! (12% ~ 17%) , Renewable, low energy cost

batch process (fixed amount) , Occupied space

Beers / Wines

Reacting

-> Combustion

C~2~H~5~OH + 3O~2~(Excess) --> 2CO~2~ + 3H~2~O

C~2~H~5~OH + 2O~2~(Limited) --> 2CO + 3H~2~O

-> Oxidation

Acidified potassium dichromate(VI) - K~2~Cr~2~O~7~

Orange to Green (Cr~2~O~7~^2-^ -> Cr^3+^)

Acidified potassium manganate(VII) - KMnO~4~

Purple to Colourless (MnO~4~^-^ -> Mn^2+^)

Conditions: Heat under reflux

Equation: CH~3~CH~2~CH~2~(OH) + 2[O] --(reflux / H^+^) --> CH~3~CH~2~COOH + H~2~O

-> Bacterial Oxidation

Reagents: O~2~

Equation: CH~3~CH~2~CH~2~(OH) + O~2~ --(Enzymes in bacteria) --> CH~3~CH~2~COOH + H~2~O

(production of vinegar)

Reflux Heating

A solution may be heated to a boiling point without losing the solvent to evaporation

Increasing the number of vaporization - condensation cycles that the vapor undergoes

-> Esterification

conditions: concentrated H~2~SO~4~ or H~3~PO~4~

CH~3~CH~2~OH + CH~3~CO~2~H --(H^+^, reflux) --> CH~3~CO~2~CH~2~CH~3~ + H~2~O

11.2.6 Carboxylic Acids

Physical properties:

-> b.p.随分子大小的增加而增加

-> b.p. 比对应大小的alkene更高

-> soluble in water

-> high b.p.

Reaction:

redox with metals -> Carboxylates

neutralization with alkalis -> Carboxylates

acid-base with carbonates -> Carboxylates

Esterification -> Esters

-> Redox with metals

2CH~3~CO~2~H + 2Na --> 2CH~3~CO~2~Na + H~2~

sodium ethanoate: CH~3~CO~2~Na

-> Neutralization with Alkalis

CH~3~CO~2~H + NaOH --> CH~3~CO~2~Na + H~2~O

-> Acid-base with Carbonates

2CH~3~CO~2~H + Na~2~CO~3~ --> CH~3~CO~2~Na + CO~2~ + 2H~2~O

-> Esterification

CH~3~CO~2~H + CH~3~CH~2~OH --(H^+^, Reflux) --> CH~3~CO~2~CH~2~CH~3~ + H~2~O

CH~3~CO~2~CH~2~CH~3~: ethyl ethanoate

和上面的一样

11.2.7 Ethanoic Acid & Esterification Reactions

11.3 Polymers(!)

11.3.1 Polymers

11.3.2 Addition & Condensation Polymers

11.3.3 Plastics & their Disposal

11.3.4 Proteins

12. Experimental Techniques & Chemical Analysis

Polystyrene Cup: minimize th

12.1 Experimental Techniques

12.1.1 Apparatus for Measurements

time: stopwatch

temp: thermometer / digital probe

mass: digital balance(needs to be tared(set to zero))

volume-liquids

(measuring cylinders)

graduated: 带有刻度的

volume-gases

Advantage & Disadvantage

12.1.2 Solutions

residue [ˈrezɪdjuː]

12.1.3 Acid-Base Titrations

细节懒得写了

Common acid-base indicators

Indicator	Colour in acid	Colour in alkali	Colour in neutral
Litmus solution	Red	Blue	Purple
Red litmus paper	Stays red	Turns blue	No change
Blue litmus paper	Turns red	Stays blue	No change
Methyl orange	Red	Yellow	Orange
Phenolphthalein	Colourless	Pink	Colourless
Thymolphthalein	Colourless	Blue	Colourless

12.2 Separation & Purification

12.2.1 Paper Chromatography(色谱法)

used to separate substances that have different solubilities in a given solvent

capillary action: 毛细效应

12.2.2 Locating Agents & Rf Values

locating agents: react with the sample and produce a coloured product which is then visible

Rf Value(Retention Factor): distance travelled by substance / distance travelled by solvent

12.2.3 Separation & Purification Techniques

Filtration

used to separate an undissolved solid from a mixture of the solid and a liquid / solution

Crystallisation

used to separate a dissolved solid from a solution, when the solid is more soluble in hot solvent than in cold

saturated solution: 饱和溶液

(dipping a clean, dry, cold glass rod into the solution)

(还要用distilled water to remove any impurities and then allowed to dry)

Simple Distillation

used to separate a liquid and soluble solid from a solution

冷凝管：condenser

Fractional Distillation

fractionating column

thermometer: 温度计

Assessing purity

Pure substances: melt and boil at specific and sharp temp

Mixtures: a range of melting and boiling points

如果样本不纯：b.p.更高m.p.更低

12.3 Identification of Ions & Gases

12.3.1 Identification of Anions

12.3.2 Identification of Cations

Additional Method	KMnO4
Cl-
Br-	No color
I-	Change orange

（Al,Zn)Excess->amphoteric(两性的)可以和碱反应

Clear: 像水一样可以看穿

Colourless: 没有颜色

flame test: blue Bunsen flame

12.3.3 Identification of Gases

神秘化学知识

离子：


	Cr3+	Green
	Mn2+	Pink
	Fe2+	Green
	Fe3+	Orange
	Ni2+	Green
	Cu2+	Blue
	Co2+	Pink
	Zn2+, Na+, K+, Ca2+, Mg2+	Colourless

区分Cl, Br, I的方法

Cl-	Br-	I-
white	cream	yellow
+Nh3 dissolve!	x	x
x	x	+H2O2 yellow solution bubbling
x	+KMnO4 yellow solution	+KMnO4 Brown solution

Reference

savemyexams

Other internet resources ...

Chapter 1-Physical quantities and units

Mon, 15 Sep 2025 00:00:00 GMT

1 Physical quantities and units

1 Physical quantities and units

Updated on 2025-10-31

1.1 Physical quantities

1 understand that deformation is caused by tensile or compressive forces (forces and deformations will be assumed to be in one dimension only)

2 understand and use the terms load, extension, compression and limit of proportionality

3 recall and use Hooke’s law

4 recall and use the formula for the spring constant k = F / x

5 define and use the terms stress, strain and the Young modulus

6 describe an experiment to determine the Young modulus of a metal in the form of a wire

Physical quantity := a quantity that can be measured and consists of a numerical magnitude and unit.

Quantity	Size
Diameter of an atom	$10^{−10} \mathrm{m}$
Wavelength of UV radiation	$10 \mathrm{nm}$
Height of an adult human	$2 \mathrm{m}$
Distance between Earth and Sun (1 AU)	$1.5 × 10^{11} \mathrm{m}$
Mass of a hydrogen atom	$10^{−27} \mathrm{kg}$
Mass of an adult human	$70 \mathrm{kg}$
Mass of a car	$1000 \mathrm{kg}$
Seconds in a day	$90 000 \mathrm{s}$
Seconds in a year	$3 × 10^7 \mathrm{s}$
Speed of sound in air	$300 \mathrm{ms^{−1}}$
Power of a light bulb	$60 \mathrm{W}$
Atmospheric pressure	$1 × 10^5 \mathrm{Pa}$

From Save My Exams

For AS: $g = 9.81ms^{-2}$

1.2 SI units

Base quantities are the quantities on the basis of which other quantities are expressed.

Derived quantities are the quantities that are expressed in terms of base quantities.

A derived quantity has an equation which links to other quantities (e.g. $F=ma$).

Base Quantities	SI Units
Length	metre ($\mathrm{m}$)
Mass	kilogram ($\mathrm{kg}$)
Time	second ($\mathrm{s}$)
Current	Ampere ($\mathrm{A}$)
Temperature	Kelvin ($\mathrm{K}$)
Amount of substance	Molar ($\mathrm{mol}$)
Luminous intensity	Candela ($\mathrm{cd}$)

Derived Quantities	Units
Power	$\mathrm{kgm^2s^{-3}}$
Charge	$\mathrm{As}$
Voltage	$\mathrm{kgm^2s^{-3}A^{-1}}$

Factor ($10^x$)	Name	Symbol
12	tera	T
9	giga	G
6	mega	M
3	kilo	k
-1	deci	d
-2	centi	c
-3	milli	m
-6	micro	μ
-9	nano	n
-12	pico	p

Homogeneity of an equation

An equation is homogeneous if quantities on BOTH sides of the equation has the same unit.

A homogeneous equation may not be physically correct, but a physically correct equation will always be homogeneous.

:::note[question] The speed $v$ of a liquid leaving a tube depends on the change in pressure $\Delta P$ and the density $\rho$ of the liquid. The speed is given by the equation

$$ v = k(\frac{\Delta P}{\rho})^n $$

Where k is a constant that has no units

What is the value of n? :::

:::tip[Significant figures] Digits considered significant: non-zero digits, zeros who:

appearing anywhere between two non-zero digits
trailing zeros in a number containing a decimal point

Digits considered not significant: leading zeros, trailing zeros in a number without a decimal point :::

1.3 Errors and uncertainties

Random errors:

values are scattered about the true value
can be reduced by average / take readings in different ways (e.g. different points along a wire)
Examples: Reading scales from different angles

Systematic errors:

the average / peak is not the true value
the reading is larger or smaller than (or varying from) the true reading by a constant amount
can be eliminated by careful calibration
Examples: Zero Error, Parallax Error

Precision := the range of the values / how close the result is to each other / the size of the smallest division

affected by random error
improve: repeat and average

Accuracy := how close the result is to the true value

affected by systematic error
improve: technique, accurate instrument
Measured by average

Uncertainty Calculation

Absolute Uncertainty (Always 1 s.f. for the final result)

$y = b \pm c \Rightarrow \Delta y = \Delta b + \Delta c$

Percentage Uncertainty (1 / 2 s.f.)

$ \left. \begin{aligned} &y=b\cdot c \ &y = \frac{b}{c} \end{aligned} \right} \Rightarrow \frac{\Delta y}{y} = \frac{\Delta b}{b} + \frac{\Delta c}{c} $

$y = a^n \Rightarrow \frac{\Delta y}{y} = n \cdot \frac{\Delta a}{a}$

When the value times a constant, the absolute uncertainty changes but the percentage uncertainty doesn't.

As the s.f. of the absolute uncertainty is always one, the s.f. of the value can therefore be determined.

1.4 Scalars and Vectors*

Scalar	Vector
magnitude	magnitude + direction
Distance, Speed	Displacement, Velocity

You also need to know:

[x] Vector Addition & Subtraction
[x] Represent a vector as two perpendicular components.

Direction : N of E 30° / 30° above x-axis (math)

Remember always to include a direction when the result is a vector.

1.? Measurements

Length

Method	Max / cm	Smallest Division / mm
Measuring Tape	150	1
Metre Rule	100	1
Vernier Caliper	15	0.02
Micrometer Screw Gauge	2.5	0.01

Vernier Caliper(游标卡尺): main scale + vernier scale

Micrometer Screw Gauge: main scale(0.5) + fractional scale(0.01)

Remember to:

[x] Check zero
[x] Repeat & Average
[x] Avoid parallax error

Mass

balance

1.?? Uncertainties

I've taken these notes on class but they are neither in the syllabus nor on past papers. Anyway, I put them here.

Uncertainty

Three main types of uncertainty:

Random Uncertainties
Systematic Errors
Reading Uncertainties

The Limit of Reading of a measurement is equal to the smallest graduation of the scale of an instrument.

The Degree of Uncertainty of a reading (end reading) is equal to half the smallest graduation of the scale of an instrument.

Absolute - fractional errors - percentage errors

1 mm - 1/208 - 0.48%

Simulation of Wave Functions in Quantum Mechanics

Sat, 02 Aug 2025 00:00:00 GMT

Simulation of Wave Functions in Quantum Mechanics

Simulation of Wave Functions in Quantum Mechanics

(Cambridge Summer School's Presentation)

written in jupyter notebook by Yiran Feng (Leon) 2025-08-02

Step = QMSim
Step.Gaussian = [-5, 0.5, 4]
Step.Potential = np.array([0] * 120 + [20] * 80)
%manim -qh Step

<video src="https://image.haoye.plus/QMVideo/wall.mp4" controls autoplay loop style="max-width: 100%;"> Your browser does not support the <code>video</code> element. </video>

Introduction

In chapter 2 and chapter 3, we've learnt about wave function in quantum mechanics and its characteristics, however, in a rather mathematical level, with equations and deductions. In this presentation, I'll present you a python simulation of wave functions in different situations, giving you a intuitive way of understanding quantum mechanics.

For simplicity, all constants are set to one in this simulation, including mass, planck's constant, etc.

# Libraries
import numpy as np
import scipy as sp
from matplotlib import pyplot as plt
from manim import *
from IPython.display import HTML
from copy import deepcopy as dc
from random import random
import tqdm

# Variables & Constants
inf = 100
x = np.linspace(-10, 10, 200)
y = np.linspace(-10, 10, 200)
X, Y = np.meshgrid(x, y)

# Useful functions
def find_nearest(array, value):
        array = np.asarray(array)
        idx = (np.abs(array - value)).argmin()
        return idx
    
def find_nearest_val(array, value):
        array = np.asarray(array)
        idx = (np.abs(array - value)).argmin()
        return array[idx]

Simulation on 1D

Basically, the simulation consists of two parts: Initialization and Evolution.

Initialization

The state of the system can be initialized with two functions: the initial state of the wave function and the potential function.

By considering different initial states of the wave function, we can change the position, the spread, and the momentum of the particle.

By changing the potential function, we can simulate different situations, for example, harmonic oscillator and quantum channel.

Look into the code. The class Simulation1D takes in two variables. phi_0 means the initial state of the wave function, and v defines the potential. The wave function is automatically normalised by the function _normalise, which is called inside the initialization, and probability ( which is basically $|\phi(x)|^2$ ) gives us the probability, of course.

class Simulation1D():
    def __init__(self, phi_0, v):
        self.phi = dc(phi_0); self.v = dc(v)
        self.dx = x[1] - x[0]; self.len = len(phi_0)
        self._normalise(); self._hamiltonian()
        self.prob = []; self.prob_updated = False
        
    def _normalise(self):
        self.phi /= np.linalg.norm(self.phi)
        self.prob_updated = True
        self.prob = (self.phi * self.phi.conjugate()).real
        
    def probability(self, pos = None):
        if not self.prob_updated:
            self._normalise()
        if pos:
            return self.prob[find_nearest(x, pos)]
        else:
            return self.prob

Evolution

From chapter 2 and chapter 3, we've learnt that when a system is free from interactions with measuring devices, the evolution of the wave function can be calculated by the Schrödinger equation (44) (Postulate 6)

$$ i\hbar \frac{\partial ψ(x,t)}{\partial t} = \left [ -\frac{\hbar ^ 2}{2m} \frac{\partial^2}{\partial x^2} + V(x) \right ] ψ(x,t) $$

In our cases, the mass and $\hbar$ is set to 1. Introducing the hamiltonian operator $\hat H$, the 1-dimensional time-dependent Schrödinger equation (TDSE) can be deduced

$$ \frac{\partial}{\partial t} ψ(x, t) = -i\hat H ψ(x, t) $$

where

$$ \hat H = -\frac{1}{2} \nabla ^2 + V(x) $$

In this equation, the discrete Laplace operator can be given as convolution with the finite-difference kernel, $[1, -2, 1]$, results in a symmetric Tridiagonal Toeplitz matrix with the finite-difference coefficients along the diagonals. Combining this matrix with the potential $V=[V_0, V_1, ..., V_N]$, a full Hamiltonian operator in matrix form can be obtained

$$ \hat H = -\frac{1}{2\Delta x^2} \begin{bmatrix} -2 & 1 & \quad & \quad & \quad \ 1 & -2 & 1 & \quad & \quad \ \quad & \quad & \ddots & \quad & \quad \ \quad & \quad & 1 & -2 & 1 \ \quad & \quad & \quad & 1 & -2 \ \end{bmatrix} + \begin{bmatrix} V_0 & \quad & \quad & \quad & \quad \ \quad & V_1 & \quad & \quad & \quad \ \quad & \quad & \ddots & \quad & \quad \ \quad & \quad & \quad & V_{N-1} & \quad \ \quad & \quad & \quad & \quad & V_N \ \end{bmatrix} $$

def _hamiltonian(self):
    """Returns Hamiltonian using finite differences."""
    L = [[0 for j in range(self.len)] for i in range(self.len)]
    for i in range(self.len):
        for j in range(self.len):
            if i == j:
                L[i][j] = -2
            if abs(i-j) == 1:
                L[i][j] = 1
    
    # Somehow it doesn't work...
    # L = sp.sparse.diags([1, -2, 1], offsets=[-1, 0, 1], shape=(self.len, self.len))
    
    L = np.array(L) / self.dx ** 2
    H = -L / 2 + sp.sparse.spdiags(self.v, 0, self.len, self.len)
    self.H = sp.sparse.csc_matrix(H)
    
Simulation1D._hamiltonian = _hamiltonian

If the Hamiltonian is independent of time, a time evolution operator(U) can be obtainted

$$ ψ(t+\delta t) = Uψ(t) $$

where

$$ U = e^{-i\hat H \delta t} $$

Multiplying the wave function with the operator $m$ times, we can advance the time steps to $t + m\delta t$

$$ ψ(t+m\delta t) = U^mψ(t) $$

The code below calculates the time evolution operator based on the hamiltonian and dt, and applies the operator to the wave function, which is also normalized after the procedure.

def simulate(self, dt = 1e-3):
    """Generates wavefunction and time at the next time step."""
    U = sp.sparse.linalg.expm(-1j * self.H * dt)
    #U[1E-10 > (U.real**2 + U.imag**2)] = 0
    self.phi = U @ self.phi
    self.phi[self.v > inf-1] = 0
    self._normalise()
    
Simulation1D.simulate = simulate

Wave Function Representation

We use a localized Gaussian wave packet centred at $x_0$ with average initial momentum, $p_0$ , and Gaussian width, $\sigma_0$ . The wave function is given by

$$ ψ(x, 0) = \left ( \frac{1}{2 \pi \sigma_0^2 } \right ) ^ \frac{1}{4} \mathrm {exp} \left ( -\frac{(x-x_0)^2}{4\sigma_0^2} + i p_0 x\right ) $$

def gaussian_wavepacket(x0, sigma, p0):
    """Gaussian wavepacket at x0 +/- sigma, with average momentum, p0."""
    global x
    return np.exp(1j*p0*x - ((x - x0)/(2 * sigma))**2)

Simulation

After the calculations, some simulations can be done.

The class QSim takes in the parameters of the gaussian wavepacket and the potential function. It produces an animation of the evolution of the wave function in 2 seconds using manim.

class QMSim(Scene):
    def construct(self):
        phi_0 = gaussian_wavepacket(self.Gaussian[0], self.Gaussian[1], self.Gaussian[2])
        V = self.Potential
        o = Simulation1D(phi_0, V)
        
        axes = Axes(
            x_range=[-10, 10, 1],
            y_range=[0, 0.17, 1],
            x_length=10,
            axis_config={"color": GREEN},
            x_axis_config={
                "numbers_to_include": np.arange(-10, 10.01, 2),
                "numbers_with_elongated_ticks": np.arange(-10, 10.01, 2),
            },
            tips=True,
        )
        
        axes_labels = axes.get_axis_labels()
        axes_ref = axes.copy()
        
        pot_graph = axes.plot((lambda k: (V/100)[find_nearest(x,k)]), color=BLUE)
        pot_label = axes.get_graph_label(
            pot_graph, "V(x)", x_val=10, direction=UP / 2
        )
        
        prob_graph = axes.plot(o.probability, color=ORANGE)
        prob_label = axes.get_graph_label(
            prob_graph, r"|\phi(x)|^2", x_val=-10, direction=UP / 2
        )

        plot = VGroup(axes, pot_graph, prob_graph)
        labels = VGroup(axes_labels, prob_label, pot_label)

        def prob_updater(mobj, dt):
            o.simulate(dt=dt*2)
            mobj.become(axes.plot(o.probability, color=ORANGE))
            return mobj
            

        prob_graph.add_updater(prob_updater)
        prob_label.add_updater(lambda x:x.become(axes.get_graph_label(prob_graph, r"|\phi(x)|^2", x_val=-10, direction=UP / 2)))
        self.add(plot, labels)
        self.wait(2 + random()) # force update

Harmonic Oscillator

Oscillator = QMSim
Oscillator.Gaussian = [-5, 0.5, 0.1]
Oscillator.Potential = x*x
%manim -qh Oscillator

<video src="https://image.haoye.plus/QMVideo/oscillator.mp4" controls autoplay loop style="max-width: 100%;"> Your browser does not support the <code>video</code> element. </video>

Potential Step

Step = QMSim
Step.Gaussian = [-5, 0.5, 4]
Step.Potential = np.array([0] * 140 + [7] * 60)
%manim -qh Step

<video src="https://image.haoye.plus/QMVideo/step.mp4" controls autoplay loop style="max-width: 100%;"> Your browser does not support the <code>video</code> element. </video>

Quantum Channel

Channel = QMSim
Channel.Gaussian = [-5, 0.5, 4]
Channel.Potential = np.array([0] * 100 + [6] * 10 + [0] * 90)
%manim -qh Channel

<video src="https://image.haoye.plus/QMVideo/channel.mp4" controls autoplay loop style="max-width: 100%;"> Your browser does not support the <code>video</code> element. </video>

The real and imagery part of the wave function can also be illustrated

class QMSim2(Scene):
    def construct(self):
        phi_0 = gaussian_wavepacket(-5, 0.4, 1.4)
        V = np.array([0] * 200)
        o = Simulation1D(phi_0, V)
        
        axes = Axes(
            x_range=[-10, 10, 1],
            y_range=[-0.3, 0.3, 1],
            x_length=10,
            axis_config={"color": GREEN},
            x_axis_config={
                "numbers_to_include": np.arange(-10, 10.01, 2),
                "numbers_with_elongated_ticks": np.arange(-10, 10.01, 2),
            },
            tips=True,
        )
        
        axes_labels = axes.get_axis_labels()
        axes_ref = axes.copy()
        
        real_graph = axes.plot(lambda x:find_nearest_val(o.phi.real,x), color=BLUE)
        real_label = axes.get_graph_label(
            real_graph, r"Re{\phi(x)}", x_val=-10, direction=UP / 2
        )
        
        imag_graph = axes.plot(lambda x:find_nearest_val(o.phi.imag,x), color=YELLOW)
        imag_label = axes.get_graph_label(
            imag_graph, r"Im{\phi(x)}", x_val=10, direction=UP / 2
        )

        plot = VGroup(axes, real_graph, imag_graph)
        labels = VGroup(axes_labels, real_label, imag_label)

        def real_updater(mobj, dt):
            o.simulate(dt=dt*2)
            mobj.become(axes.plot(lambda k:(o.phi.real)[find_nearest(x,k)], color=BLUE))
            return mobj

        def imag_updater(mobj, dt):
            mobj.become(axes.plot(lambda k:(o.phi.imag)[find_nearest(x,k)], color=YELLOW))
            return mobj
            

        real_graph.add_updater(real_updater)
        imag_graph.add_updater(imag_updater)
        real_label.add_updater(lambda x:x.become(axes.get_graph_label(real_graph, r"Re{\phi(x)}", x_val=-10, direction=UP / 2)))
        imag_label.add_updater(lambda x:x.become(axes.get_graph_label(imag_graph, r"Im{\phi(x)}", x_val=10, direction=UP / 2)))
        
        self.add(plot, labels)
        self.wait(2 + random()) # force update
        
%manim -qh QMSim2

<video src="https://image.haoye.plus/QMVideo/realimag.mp4" controls autoplay loop style="max-width: 100%;"> Your browser does not support the <code>video</code> element. </video>

Simulation on 2D

Applying the Schrödinger equation in 2D, we can simulate how a 2D wave function evolves.

However, the calculation for 2D simulation is too complicated for my laptop to run an animation of it. Hence merely an image of the initial state of a 2D wave function is obtained in a relatively low resolution.

# Constants
x = np.linspace(-10, 10, 100)
y = np.linspace(-10, 10, 100)
X, Y = np.meshgrid(x, y)

class Simulation2D(): # For simplicity, some code's folded up
    def __init__(self, phi_0, v):
        self.phi = dc(phi_0); self.v = dc(v)
        self.dx = x[1] - x[0]; self.dy = y[1] - y[0]
        self.lenx = len(phi_0[0]); self.leny = len(phi_0)
        self._normalise(); self._hamiltonian()
        
    def _normalise(self):
        self.phi /= np.linalg.norm(self.phi)

    def _hamiltonian(self):
        """Returns Hamiltonian using finite differences."""
        L1 = [[0 for j in range(self.lenx)] for i in range(self.lenx)]
        for i in range(self.lenx):
            for j in range(self.lenx):
                if i == j:
                    L1[i][j] = -2
                if abs(i-j) == 1:
                    L1[i][j] = 1
                    
        L2 = [[0 for j in range(self.leny)] for i in range(self.leny)]
        for i in range(self.leny):
            for j in range(self.leny):
                if i == j:
                    L2[i][j] = -2
                if abs(i-j) == 1:
                    L2[i][j] = 1

        # 2D Laplacian using Kronecker products
        L1 = np.array(L1) / self.dx ** 2; L2 = np.array(L2) / self.dy ** 2
        I_x = sp.sparse.identity(self.lenx); I_y = sp.sparse.identity(self.leny)
        L2D = sp.sparse.kron(I_y, L1) + sp.sparse.kron(L2, I_x)
        H = (-L2D / 2).toarray()
        for i in range(len(self.v)): # Somehow sp.sparse.diags doesn't work qaq
            H[i+i*self.lenx] = self.v[i//self.lenx][i%self.lenx]
            
        self.H = sp.sparse.csr_matrix(H)
        
    def simulate(self, dt = 1e-3):
        """Generates wavefunction and time at the next time step."""
        U = sp.linalg.expm(-1j * self.H.toarray() * dt)
        U[(U.real**2 + U.imag**2) < 1E-10] = 0
        phi_flat = self.phi.flatten()
        phi_flat = U @ phi_flat
        self.phi = phi_flat.reshape((self.lenx, self.leny))
        self.phi[self.v > inf-1] = 0

    def probability(self):
        return (self.phi * self.phi.conjugate()).real

def gaussian_wavepacket_2D(x0, y0, sigma, p0):
    """Gaussian wavepacket at x0 +/- sigma, y0 +/- sigma with average momentum, p0."""
    global x, y
    return np.exp(1j*p0*x - (((X - x0)**2+(Y - y0)**2)/(2 * sigma**2)))

def Free2D():
    phi_0 = gaussian_wavepacket_2D(3, 0, 0.5, -1)
    V = X*X+Y*Y
    o = Simulation2D(phi_0, V)
    for i in tqdm.trange(0):
        o.simulate(0.5)

    from matplotlib import cm
    from matplotlib.ticker import LinearLocator
    
    fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
    
    
    # Plot the surface.
    surf = ax.plot_surface(X, Y, o.probability(), cmap=cm.coolwarm,
                           linewidth=0, antialiased=False)
    
    # Customize the z axis.
    #ax.set_zlim(-1.01, 1.01)
    ax.zaxis.set_major_locator(LinearLocator(10))
    # A StrMethodFormatter is used automatically
    ax.zaxis.set_major_formatter('{x:.02f}')
    
    # Add a color bar which maps values to colors.
    fig.colorbar(surf, shrink=0.5, aspect=5)
    
    plt.show()
    
Free2D()

Prospect

Some improvements could also be made regarding this simulation and animation ...

Record physical quantities (momentum, energy, ...) during the simulation
Increase the resolution for a higher accuracy
Complete simulations in 2D
...

Thanks for listening ~

Reference

https://www.astro.utoronto.ca/~mahajan/notebooks/quantum_tunnelling.html

https://docs.manim.community/

IG Maths(Extended) 复习笔记

Tue, 16 Apr 2024 00:00:00 GMT

This note might not cover everything.

（有些很简单的我就没记，最好考前看一眼syllabus: here

有任何错误/补充欢迎评论指正ouo

Number
Algebra & Graphs
Geometry
Probability & Statistics
Some own experience

Number

数

Real Numbers(ℝ):实数 Integers(Whole Numbers)(ℤ):整数 Natural numbers(ℕ):自然数(不包括0？查一下syllabus) 正整数(N+)(N*) Rational Numbers(Q):有理数 A factor: 因数 A multiple:倍数 index/order/exponents:指数 reciprocal:倒数

quotient:商 Approximately equal to:约等于 identical to:全等于 bracket:括号竖式乘法除法

集合

{(x, y) : y = 2x + 1}

E:universal set

∅:empty set

n(∅) = 0

upper case: set , lower case: element

a ∈ A means a is an element of A

A ⊆ B means A is a subset of B

A ⊂ B means A is a proper subset of B (A≠B)

A∩B intersection A∪B union A' not A

质因数 (与最大公因数最小公倍数)

Prime tree prime factor decomposition (PFD) indices are even: square number indices are multiples of 3: cube number the highest common factor (HCF)最大公因数 the lowest common multiple (LCM)最小公倍数

指数运算&科学表达式

base number: 底数 index: 指数

square root:平方根 cube root:立方根 A nth root standard form: 科学表达式

分数

numerator: 分子 denominator: 分母 mixed numbers: 带分数 improper fraction(top heavy fraction): 假分数

比例

A multiplier, p, is the decimal equivalent of a percentage increase or decrease

利息

simple interest: 单利 compound interest: 复利 depreciation: 约等于复利 substitute: 代入 decay: 下降

FDP

terminating decimal: 有限小数 recurring decimal: 无限循环小数错位相减

Ratio

direct proportion: 正比 inverse proportion: 反比

Compound Measures

没啥好说的

时间货币转换

millennium: 千年 midday: 12pm midnight: 12am am/pm : 12 1 2 3 4 5 6 7 8 9 10 11

Each column represents a different bus/train – these are often called “services”

The time in each cell usually indicate departure times(when the bus/train leaves that stop/station)

The last location on the list usually shows the arrival time

GBP: 英镑£

汇率类问题单独开一行写A货币比B货币等于几比几，下面一行写x:几几几。再用除法算出scale factor

钱要保留两位小数！！！！

近似估计边界

estimate: 一般一个sf

LB <= x < UB

计算：x+-一半精度

计算器

负数：(-) rounding 不必在计算中进行，用3.1415...省略号表示

Algebra & Graphs

基础

term: 单项式 coefficient: 系数 constants: 常数 expression: 表达式 equation: 方程/等式 formula: 公式(F=ma) inequality: 不等式 substitution: 代入 v=u+at v2-u2=2as s=ut+0.5at2 "like" terms: 同类项

a^x=a^y x=y

指数根号

展开括号，因式分解

expanding: 展开 factorisation: 因式分解 quadratic expression: 二次表达式 monic quadratic expression: a=1 non-monic : a!=1 十字相乘 discriminant: 判别式(b2-4ac)

线性方程，不等式

二次方程

completing the square: a(x+p)2+q quadratic formula: 二次方程求根公式 repeated root: 两个相同的根

重整式子

(rearrange formulae) (changing the subject)

联立方程

linear simultaneous equations: 线性方程组 Elimination: 加减消元 substitution: 代入

分式

分式: Algebraic Fractions

列方程解方程

5 lots of something: 5x polygon: 多边形 parallelogram: 平行四边形 rhombus: 菱形 prisms: 柱体 pyramids: 锥体 regular polygon: 正多边形 interpret: 解释

函数

Composite(compound) functions: 复合函数 Inverse Functions: 反函数

数列

Sequences: 数列 term: 项 position: 索引(ish?) position-to-term rule: 通项公式 term-to-term rule: 由an前面的项得到an linear(arithmetic)/quadratic(二次序列)/geometric(等比序列) sequences cubic sequence: the third differences are constant common ratio: 公比 common difference: 公差

a fibonacci sequence: 泛指an=a(n-1)+a(n-2)的序列，可以改变前两项 the fibonacci sequence: 前两项为1

求quadratic sequence的a: the second difference 除以二剩下的用原数列减an2,得到一个等差数列

坐标系

steep: 陡峭的求斜率：rise over run Pythagoras’ Theorem: 勾股定理

线型图象

ax+by+c=0 -> 斜率: -a/b 截距: -c/b parallel: 平行(相同的直线不是平行) the negative reciprocal: 倒数取反

二次图像

parabola: 抛物线

解不等式

有等号的用实线，否则用虚线要shade unwanted的area

生活中的图像

conversion/convert: 转换 deceleration: 减速

微分

the derivative: 导数 the derived function: 导函数 f'(x) -> f-dashed-of-x Turning points/stationary points: 导数为0的点 peak/trough: 峰/谷 positive cubic: 左边最大值，右边最小值 negative cubic: 左边最小值，右边最大值 d2y/dx2 optimisation/optimal: 优化

Geometry

基本

symmetry: 对称 the order of rotational symmetry: 转一圈有几次和自己一样 (有的时候order是1也会说成没有rotational symmetry) n lines of symmetry(有n条对称轴) mirror line polygon: 多边形 cuboid: 长方体 cylinder: 圆柱

triangle
quadrilateral
pentagon
hexagon
heptagon
octagon
nonagon
decagon

cube: 9 planes of symmetry 一般来说，柱体的planes of symmetry是横截面的对称轴数量加1 而锥体的是横截面对称轴数量 equilateral triangle: 等边三角形 isosceles triangle: 等腰三角形 parallelograms: 平行四边形 rhombuses(rhombi): 菱形 trapezium: 梯形（一对边平行） kite: 两组邻边相等的四边形 bisect: 平分 obtuse angle: 钝角 acute angle: 锐角 dagonal: 对角线 perimeter: 周长 circumference: 圆的周长

prism: 柱体 pyramid: 锥体 square-based pyramid cone: circular base tetrahedron: base is an equilateral triangle

face/vertex(vertices)/edge

net: 展开图

1cl = 10 ml

1 hectare (ha) = 10 000 m2

多边形和平行线里的角

basic angle properties:

Angles that meet at a point add up to 360°
Angles that meet at a point on a straight line add up to 180°
Vertically opposite angles are equal(对顶角相等) regular polygon: 正多边形

sum of interior angles = 180° × (n-2) 外角(exterior angle)和永远为360°

Corresponding angles are equal(同位角相等) Alternate angles are equal(内错角相等) Allied (co-interior) angles add to 180°(同旁内角互补) (on parallel lines)

transverse: 跨过两个平行线的直线

bearings constructions & scale drawings

bearing: 从北方开始顺时针测量，保留三位有效数字，不写degree symbol (画图记得画north line) 面积用A(Area)

圆

所有的circle theorem在考试中都要写出来 Circle Theorem: The angle subtended by an arc at the centre is twice the angle at the circumference(这个定理必须写出来) Circle Theorem: The angle in a semicircle is a right angle(俺也一样)

chord(弦) Any equal chords are equidistant from the centre of the circle Circle Theorem: The perpendicular bisector of a chord is a radius Circle Theorem: A radius and a tangent meet at right angles Two tangents from a circle to the same point outside of a circle are equal

cyclic quadrilaterals(圆内接四边形) Circle theorem: Opposite angles in a cyclic quadrilateral add up to 180°

Circle Theorem: Angles at the circumference subtended by the same arc are equal(Angles in the same segment are equal) Circle Theorem: Alternate Segment Theorem(弦切角定理)

面积和周长

compound shapes: 由多个简单图形拼接出来的图形 rectangle: A=lw triangle: A=1/2 bh trapezium: A=1/2 (a+b)h parallelogram: A=bh

圆和扇形和弧

arc:弧 minor arc(劣弧) major arc(优弧) sector: 扇形 minor sector major sector

体积和表面积

volume: 体积 volume of a pyramid: 三分之一底乘高圆的体积：4/3 πr3 frustum: 圆台

surface area: 表面积 slant height: 斜高 surface area of a sphere = 4πr2

全等和相似(congruence & similarity)

congruent/congruence: 全等 SAS,ASA,AAS,SSS,RHS similar: 相似证明任意多边形相似：对应边成比例三角形：AAA Equivalent: 对应的

直角三角形

Pythagoras’ Theorem: 勾股定理 hypotenuse: 斜边 opposite: 对边 Adjacent: 邻边

Trigonometry: 三角学 sin: 奇函数 cos: 偶函数

the angles of elevation and depression

sine, cosine rule & 三角形面积

the sine rule: a/sinA = b/sinB = c/sinC the cosine rule: cosA = (b2+c2-a2) / 2bc or a2=b2+c2 - 2bc cosA

A = 1/2 ab sinC 表示角的方法: ABC上面加一个^

三维三角函数

d2=a2+b2+c2

三角函数图像和方程

先label出关键点，再连接成线

向量

magnitude direction translation vector scalar: 标量 magnitude(modulus): |a| specific vector: AB-> general vector: a 证明三点共线：找出两个向量平行

变化

original shape: object(A,B,C) transformed shape: image(A',B',C')

translation Shape A has been translated using the vector (一个向量)

reflection

Shape A has been reflected in the line x=-1 to create shape B

rotation Rotation, 90o clockwise with centre (-4, 0) enlargement The length scale factor is 2, therefore the area scale factor will be 2^2 = 4, hence, the area of C' is 4 times larger than C

Shape A has been enlarged using a scale factor of 3 and a centre of enlargement (9, 9) to create shape B

C.o.E

~~objection~~

Probability & Statistics

基础

An experiment is a repeatable activity that has a result that can be observed or recorded Trials are what we call the repeats of the experiment An outcome is a possible result of a trial An event is an outcome or a collection of outcomes A sample space is the set of all possible outcomes of an experiment The probability of event A is denoted as P(A)

The complement of event A is the event where event A does not happen A' mutually exclusive events: 发生了A就不可能发生B，A交B为空集

sample space: 所有可能的结果 possibility diagram: combining two things using a grid

Relative frequency(estimate probabilities from experimental data)

expected frequency(the number of times you would expect a particular outcome to occur when repeating a trial numerous times)

概率图像

Two Way Tables The row/column totals are sometimes called marginal (or sub-) totals Where the row totals and column totals meet, we have the grand total Conditional probabilities are sometimes written using the 'straight bar' notation P(A|B)

Venn Diagrams

Tree Diagrams

conditional probability

平均和极差

统计图像

Histogram(直方图)

cumulative frequency & box plots

Correlation is a way of describing the way two quantities are related to each other

positive/negative/no coorelation

correlation doesn't mean causation

scatter graphs & correlation

Some own experience

记得带量角器多于一分记得写过程 show all your working: 每一步都要写(假分数变带分数的过程也要) degree 保留一个小数位有一些题目不需要3sf，直接写出答案圆切角定理！！！

Arno buys a student ticket for $43.68 . This is a saving of 16% on the full price of a ticket. Calculate the full price of a ticket.

43.68是减去16%后的价格，并不是那16%

看清题目要求increase还是自己

Reference: savemyexams

AC自动机(Aho-Corasick Algorithm)

Sun, 19 Nov 2023 00:00:00 GMT

~~自动AC机~~

前置知识：kmp算法

还没加图片qwq（不过也能看）

引入
Trie树
Fail指针
Fail 指针优化
查询
代码实践

引入

kmp算法处理了一个模式串在一个文本串中匹配的场景。如果是多个模式串在一个文本串匹配呢？

Trie树

由于我们在上一章详细讨论了字典树，这章就不做赘述

Fail指针

如同kmp算法一样，AC自动机高效的原因也是在失配的时候可以及时调整，避免重复运算，用一个 fail 数组实现这一流程。

fail[i] 所储存的值 u 是存在于字典树中的 i 的最长后缀。

fail[i] 的值可以由比点 i 辈分还高的点的 fail 值得到。我们先来看一下过程

考虑计算 fail[i] 的值：

让 u = fa[i]，也就是i的父节点

如果 fail[u] 的子节点中有 i 的值，那么 fail[i] = fail[u]的那个子节点
如果 fail[u] 的子节点中没有 i 的值，那么 u = fail[u] ，从头继续
如果 u 已经是根节点了，那么停止循环， fail[u] = 0

为什么这样可行呢？

因为 i 的父节点已经帮 i 找好了 i 前一个字符串的最长公共后缀的元素在哪里。对于 i 来说，只要“子承父业”，继承父亲所找到的那个元素就好了，如果“父业”（也就是 fail[fa[i]] 节点）下有他儿子就好。（对应步骤1）

如果没有也没关系。继承不了父亲的也可以沿着父亲找到的那个元素的链条往上爬，再往上找，直到找到某个元素使这个元素的子节点下面有 i 就行。（对应步骤2）如果实在没有直接 fail[i] = 0（对应步骤3）

Fail 指针优化

看起来很美好，可是如果一直向上追溯肯定时间不够。

我们可以给每个元素都加上“虚拟儿子”，凑齐二十六个字母（如果题目有数字那也要包括）。这样子元素就可以直接“子承父业”， fail[i] = fail[fa[i]].son[i对应的字符的值]（不用上一节一直往上爬（步骤2）了，因为“父业”下面已经有这个儿子了~~（虽然可能是虚拟的）~~）。i的“虚拟儿子” c （也就是 i 原本没有 c 这个儿子）是i.son[c] = fail[i].son[c]。

前面一句话好理解。那么最后一句话呢？

其实“虚拟儿子”就保存着我们上一节循环后的答案。这里“真实儿子”对应着步骤1找到了元素，“虚拟儿子”对应着步骤2没找到元素。因为 i 的虚拟儿子 c 是由 fail[i] 的儿子 c 得到的。如果它是真实的那么最终 i 的虚拟儿子 c 就对应着另一个元素 fail[fa[d]] = i,d的值为c 的 fail[d] 的值，fail[d] = i.son[c]。即使它是虚拟的但他也是由fail[fail[i]] 的儿子 c 得到的。一直向上，和上一节的循环一样。如果遇到了真实的停，直到根节点。只不过是把这个过程从上往下进行了而已。

用BFS（广度优先搜索）从上往下更新，可以保证更新一个节点时比它辈分还大的节点已经更新完了。

引用一句名言

Talk is cheap. Show me the code.

--- Linus

queue<int> que;
void bfs(){
    for(int i=0;i<=25;i++){
        if(tr[0][i])que.push(tr[0][i]);
    }
    while(!que.empty()){
        int u=que.front();
        que.pop();
        for(int i=0;i<=25;i++){
            if(!tr[u][i])   tr[u][i]=tr[fail[u]][i];//创建虚拟儿子
            else{//更新fail指针
                que.push(tr[u][i]);
                fail[tr[u][i]]=tr[fail[u]][i];
            }
        }
    }
}

查询

运用虚拟儿子解决了匹配失败的问题。那么匹配成功走真的儿子，匹配失败走假的儿子，就可以忽略这一差别，直接向下走。我们上一章讲了在字符串末尾打上标记，查询的时候就可以直接向下走，然后记录遇到了几个标记，并且把他清零（如果只需要匹配一次的话）。

void find(string s){
    int u=0,c;
    for(int i=0;i<s.length();i++){
        c=s[i]-'a';
        u=tr[u][c];//向下走一步
        ans+=bo[u];
        bo[u]=0;//确保同一字符串只被统计一次
    }
    return;
}

代码实践

洛谷：P3808

#include<iostream>
#include<string>
#include<queue>

using namespace std;

#define N 1000009

int n;
int ans,cnt;
int fail[N];
int tr[N][30];
int bo[N];
 
void make(string s){
    int u=0;
    for(int i=0;i<s.length();++i){
        int c=s[i]-'a';
        if(!tr[u][c]){
            tr[u][c]=++cnt;
        }
        u=tr[u][c];
    }
    bo[u]++;
    return;
}

queue<int> que;
void bfs(){
    for(int i=0;i<=25;i++){
        if(tr[0][i])que.push(tr[0][i]);
    }
    while(!que.empty()){
        int u=que.front();
        que.pop();
        for(int i=0;i<=25;i++){
            if(!tr[u][i])   tr[u][i]=tr[fail[u]][i];//创建虚拟儿子
            else{//更新fail指针
                que.push(tr[u][i]);
                fail[tr[u][i]]=tr[fail[u]][i];
            }
        }
    }
}

void find(string s){
    int u=0,c;
    for(int i=0;i<s.length();i++){
        c=s[i]-'a';
        u=tr[u][c];
        ans+=bo[u];
        bo[u]=0;//确保同一字符串只被统计一次
    }
    return;
}

int main(){
    int n;
    string s;
    ans=0;cnt=0;

    cin>>n;

    //输入模式串
    while(n--){
        cin>>s;
        //建立trie树
        make(s);
    }

    //建立next指针
    bfs();
    
    //输入文本串
    cin>>s;
    //ac自动机
    find(s);

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

字典树(Trie)

Sat, 18 Nov 2023 00:00:00 GMT

AC自动机的前置知识（=^^）/

问题
字典树~削弱版~
字典树
查询
代码实践

问题

给定很多个文本串 t[i] 和很多个模式串 s[i] 。怎样算出每个文本串是多少个模式串的前缀？

字典树~削弱版~

我们一个一个匹配显然太慢了。有没有什么方法可以简化这个流程呢？

这就是，，，，字典树！！

可以从上面的图片看到，对于多个字符串，如果把他们的公共前缀合在一起，最终得到的结果类似于一个树。这样具有公共前缀的不同字符串只用枚举一次就可以了！！！（这就是为什么它也叫前缀树）

不过，这张图片还有点不完美。我们并不知道有几个模式串有这个前缀。可以在字典树的每个节点加一个数据 num[i]（在图片右下角），记录拥有这个公共前缀的字符串的个数。

再给每个字符串的末尾打上标记后（虽然对于上面的问题来说这个步骤不重要，但是看到下一章的AC自动机（~~自动AC机~~）来说，这个就重要了），我们就得到了一个比较完美的字典树。

可我们还没有考虑一种情况。

字典树

有没有发现，上一节这些字符串们的第一个字符都是 O

对于第一个字符不同的字符串该怎么弄呢？

我们可以定义一个虚拟的根节点。这个节点并没有实际的值，只不过是为了链接第一个字符不同的字符串们的。

为了演示方便，把根节点染成了黄色（其实代码实际用起来并不用做特别区分）。

把字符串A改为 IF 后，我们就得到了最终版本的字典树了。

查询

查询很简单。只要在文本串从头到尾遍历，然后在字典树中从上到下遍历就好了。

如果遍历着遍历着下面没节点了，说明文本串不是任何模式串的前缀。

如果遍历着遍历着文本串没了，那么此时所在的节点所记录的 num[i] 就是最终的答案。

（可以想想为什么会这样。~~（绝对不是懒得写了）~~）

代码实践

洛谷：P8306

#include<bits/stdc++.h> //万能头！！！

using namespace std;

int cnt;
int trie[3000009][70];
int num[3000009];

int c2i(char x){
    if('a'<=x and x<='z')return x - 'a' + 1;
    if('A'<=x and x<='Z')return x - 'A' + 27;
    if('0'<=x and x<='9')return x - '0' + 53;
}

inline void clearTrie(){
    for(int i=0;i<=cnt;i++){
        for(int j=0;j<70;j++){
            trie[i][j]=0;
        }
        num[i]=0;
    }
    cnt = 0;
}

inline void pushTrie(string x){
    int u=0;
    for(int i=0;i<x.length();i++){
        int c = c2i(x[i]);
        if(!trie[u][c]){
            trie[u][c]=++cnt;
        }
        u=trie[u][c];
        num[u]++;
    }
}

int queryTrie(string x){
    int i,u;
    i=u=0;
    while(i<x.length() && trie[u][c2i(x[i])]){
        u=trie[u][c2i(x[i])];
        i++;
    }
    if(i == x.length()){
        return num[u];
    }
    return 0;
}

int main(){
    int t;
    cin>>t;
    while(t--){
        clearTrie();
        int n,q;
        cin>>n>>q;
        while(n--){
            string x;
            cin>>x;
            pushTrie(x);
        }
        while(q--){
            string x;
            cin>>x;
            cout<<queryTrie(x)<<endl;
        }
    }
}

拓展kmp (exkmp/ Z function)

Sat, 11 Nov 2023 00:00:00 GMT

引入
计算extend数组
- 求解extend数组的最小值
- 拓展
next 数组
代码实践

引入

KMP算法可以求解出一个模式串在文本串中出现的位置。扩展KMP算法（Z函数）在这个思路上进行了延伸。对于文本串S的每一个后缀（如果文本串S长度为n的话，就指的是 S[i:n] ，其中 (0<=i<=n-1) ），找到这个后缀与模式串T的最长公共前缀的长度，存储在 extend[i] 中。设模式串T长度为m，不难发现，如果我们只看 extend[i] = m 的情况，相当于在文本串S找出模式串T出现的位置，就和原本的KMP算法一样了。

扩展KMP算法在国外一般叫做Z函数(Z function)。

计算extend数组

对于模式串T，我们需要预处理一个数组 next 。其第i项表示从i开始T的后缀与T的最长公共前缀的长度。next 数组的求解在下节可以看到，我们先来看看如何用 next 数组计算出 extend 数组。

和之前说的马拉车算法类似，拓展KMP算法也是利用之前的数据对暴力算法进行优化。维护一个当前所到达过的最右边的值 right 以及所对应的起点 left （即 left + extend[left] - 1 的最大值为 right ）。此时在第 i 项，默认其前面的 extend[i-1], extend[i-2], ... extend[0] 都已经更新完毕。

如果 i > right ，说明此时第 i 项还没有更新。此时就用最简单的暴力算法向前推进，并且更新 left 和 right 的值。

left = i;
while((i+extend[i])<s.length() && (extend[i])<t.length() && t[extend[i]] == s[i+extend[i]]){//思考题：为什么这里没有+1
	extend[i]++;
}
right = left + extend[i] - 1

如果 i <= right ，就可以利用 left 和 right 的值来更新 extend[i] 了。

求解extend数组的最小值

从上图结合之前学的内容可知， S[left:right+1] 和 T[0:right-left+1] 的值是相同的。也就是 S[i:right+1] 与 T[i-left:right-left+1] 的值是相同的（图中红色区域和绿色区域是相同的）。next[i-left] = 2 可以求得 T[0:2] = T[i - left:i - left + 2 + 1] 也就是黄色区域等于绿色区域的前两个。又因为红色区域等于绿色区域，所以红色区域前两个等于黄色区域。也就是文本串S以第i项开头的后缀与模式串T的最长公共前缀为2，也就是黄色区域的长度 next[i - left]。进而得到 extend[i] = next[i - left]

我们再来看一个例子。

根据上文所述的方法画出红色，绿色和黄色区域。我们会发现套用上一个结论行不通。因为黄色区域的长度已经超过了红色区域的长度。而我们只能保证红色区域与绿色区域相同，并不能保证红色区域的下一个值和绿色区域的下一个值相同，也就是 S[5] 和 T[4] 不能确定是否相同。此时就应该用红色区域的长度作为 extend[i] 的值。extend[i] = right - i + 1。

综上，可以得出一个通用式子。

extend[i] = min(right - i + 1, next[i - left]);

拓展

如果 i + extend[i] - 1 = right ，说明本次更新已经到了 s[left:right+1] 所管辖的尽头，需要对其进行更新。此时就和暴力的时候一样就好了，拓展 extend[i] 的值并且更新 left 和 right。

if(i + extend[i] - 1 > right){
    left = i;
    while((i+extend[i])<s.length() && (extend[i])<t.length() && t[extend[i]] == s[i+extend[i]]){//思考题：为什么这里没有+1
        extend[i]++;
    }
    right = i + extend[i] - 1
}

next 数组

其实和上一节很相似，只不过是文本串和模式串都是T而已。这里就直接上代码

void calNextt(){
    nextt[0] = t.length(); // 自己和自己的最长公共前缀就是自己本身
    int left,right;
    left = right = 0;
    for(int i=1;i<t.length();i++){
        if(i<=right)
            nextt[i] = min(right-i+1,nextt[i-left]);
        while((i+nextt[i])<t.length() && t[nextt[i]] == t[i+nextt[i]]){
            nextt[i]++;
        }
        if(i+nextt[i]-1>right){
            left = i;
            right = i+nextt[i]-1;
        }
    }
}

代码实践

代码实践：洛谷P5410

不要忘了用long long!!!!（改了很久的愤怒）

//LICENSE: GPL v3.0
//https://blog.haoye.plus

#include<iostream>
#include<string>
#define int long long
using namespace std;
string s,t;
int nextt[20000009];//next 为保留字，不能用
int extend[20000009];

void calNextt();
void calExtend();

signed main(){
    cin>>s>>t;

    calNextt();
    //计算答案
    int ans = nextt[0]+1;
    for(int i=1;i<t.length();i++)
        ans = ans xor ((i+1)*(nextt[i]+1));
    cout<<ans<<endl;

    calExtend();
    //计算答案
    ans = extend[0]+1;
    for(int i=1;i<s.length();i++){
        ans = ans xor ((i+1)*(extend[i]+1));
    }
    cout<<ans<<endl;

    return 0;
}

void calNextt(){
    nextt[0] = t.length(); // 自己和自己的最长公共前缀就是自己本身
    int left,right;
    left = right = 0;
    for(int i=1;i<t.length();i++){
        if(i<=right)
            nextt[i] = min(right-i+1,nextt[i-left]);
        while((i+nextt[i])<t.length() && t[nextt[i]] == t[i+nextt[i]]){
            nextt[i]++;
        }
        if(i+nextt[i]-1>right){
            left = i;
            right = i+nextt[i]-1;
        }
    }
}

void calExtend(){
    extend[0]=0;
    while((extend[0])<s.length() && (extend[0])<t.length() && t[extend[0]] == s[extend[0]]){
        extend[0]++;
    }

    int left,right;
    left = 0;
    right = extend[0]-1;
    for(int i=1;i<s.length();i++){
        if(i<=right)
            extend[i] = min(right-i+1,nextt[i-left]);
        while((i+extend[i])<s.length() && (extend[i])<t.length() && t[extend[i]] == s[i+extend[i]]){
            extend[i]++;
        }
        if(i+extend[i]-1>right){
            left = i;
            right = i+extend[i]-1;
        }
    }
}

马拉车算法 (Manacher)

Sun, 05 Nov 2023 00:00:00 GMT

马拉车算法可以用线性级时间复杂度找出最长回文子串。

回文子串
修改回文串
O(n^2) 求解
马拉车算法思路
代码实践

回文子串

考虑这么一种字符串，它正着读和倒着读的内容都一样。我们称这种字符串为回文串。

接下来的算法目的是在一个字符串的所有子串中找到一个长度最长的回文串，也就是最长回文子串。

修改回文串

根据回文串长度的奇偶性，可以将它分为两类: 长度为奇数的回文串和长度为偶数的回文串。长度为奇数的回文串中心只有一个元素，而长度为偶数的有两个。

如果对于这两种回文串进行分类讨论的话，代码会变得更加复杂。我们可以在回文串的左右两边和每个字符之间加上一个特殊字符。这样就只用讨论长度为奇数的回文串。

O(n^2) 求解

很容易想到的一种思路就是暴力枚举。以每一个元素为回文串的中心同时向左右扩散，直到碰到边缘或者左右字符不一致时停止。这被称作中心扩散法。

#include<bits/stdc++.h>
using namespace std;
char s[22000010];
int n;
int p[22000010];
int maxx;
inline void algorithm(){
    for(int i=0;i<n;i++){
        //扩散
        while(i - p[i] -1 >= 0 && i + p[i] + 1 < n && s[i+p[i]+1] == s[i-p[i]-1]){
            p[i]++;
        }
        //更新最终答案
        maxx = max(maxx,p[i]);
    }
}
int main(){
    //输入并添加特殊字符
    char c;
    c=getchar();
    while('a'<=c && c<='z'){
        s[n++]='#';
        s[n++]=c;
        c=getchar();
    }
    s[n++]='#';
    maxx = 0;
    //算法处理
    algorithm();
    //输出
    cout<<maxx<<endl;
}

代码会处理添加过特殊字符后的回文串，并记录扩散次数到p数组。

我们会发现，p数组存储的值正好是对应位置修改前的原始最长回文子串的长度。这样记录好p数组的最大值就可以知道答案了。下面是简短的证明。

以某一项元素为中心扩散最终左右两边的极限一定是特殊字符。因为不等于的情况永远不是特殊字符（或者碰到边界，不过整个字符串首位就有特殊字符，所以这个情况不难证明），所以最终这个回文串的左右两边的极限肯定都为特殊字符。

对某一个元素而言，设回文串长度为 2 * l + 1, 则除去特殊字符的原始字符串长度为 l ，p[i] 也等于 l。所以相等。

马拉车算法思路

O(n^2)算法的时间复杂度显然不占优势。利用回文串的性质可以对它进行优化

马拉车算法会记录两个值。一个是目前所有回文子串中最靠右的右端点的下标 max_right ，另一个是它所对应的回文串中心的下表 center

在进行第一个循环时，如果所在的元素 i 的下标大于 max_right 说明目前的回文子串无法覆盖到 i 。此时就只能用到上文的扩散法计算p数组的值并更新 max_right 与 center。

可如果 i 不大于 max_right ，说明有之前的回文串可以覆盖到 i 。此时就可以利用回文串的性质进行优化了。

利用 i 关于 center 对称的元素 mirror，我们可以计算出 p[center] 的最小值。

举个例子，考虑以第9项作为center的情况

对于字符串s，可能会出现下面的三种情况。

如果 p[mirror] < max_right - i (这里 max_right - i 代表着以 center 为中心的回文串最左端离 mirror 的距离)，此时 p[i] = p[mirror]。因为根据回文串的性质， mirror - p[mirror] 到 mirror + p[mirror] 是回文串必然能推出 i - p[mirror] 到 i + p[mirror] 子串也是回文串。s[ mirror - p[mirror] - 1 ] != s[ mirror + p[mirror] + 1 ] 也能推导出 s[ i - p[mirror] - 1 ] != s[ i + p[mirror] + 1 ]，证明这是最长的回文串。

如果 p[mirror] = max_right - i ，同上可知 p[i] = p[mirror]。设左端点为 left，则 s[ mirror-p[mirror]-1 ] != s[ mirror+p[mirror]+1 ] 不能推导到以 i 为中心的回文串上。所以此时需要扩散回文串并且更新 max_right 与 center。

如果 p[mirror] > max_right - i ，此时以 mirror 为中心的回文串已经超出了以 center 为中心的回文串的范围。通过以 center 为中心的回文串的性质所推导出来的结论只适用于这个回文串本身的范围。对于他左端点往左和右端点往右的对称性无法保证。设左端点为 left，可得到 s[ center-p[left]-1 ] != s[ center+p[right]+1] 。因此此时 p[i] = max_right - i。

代码实践

模版题: P3805 马拉车

C++代码

#include<bits/stdc++.h>
using namespace std;
char s[22000010];
int n;
int p[22000010];
int maxx;
inline void manacher(){
    int center,right;
    center = -1;
    right = -1;
    for(int i=0;i<n;i++){
        int mirror = center * 2 - i;
        //如果i在center回文串里面
        if (i < right){
            p[i] = min(right - i, p[mirror]);
        }
        //扩散
        while(i - p[i] -1 >= 0 && i + p[i] + 1 < n && s[i+p[i]+1] == s[i-p[i]-1]){
            p[i]++;
        }
        //更新right和center
        if(i+p[i]>right){
            right = i+p[i];
            center = i;
        }
        //更新最终答案
        maxx = max(maxx,p[i]);
    }
}
int main(){
    //输入并添加特殊字符
    char c;
    c=getchar();
    while('a'<=c && c<='z'){
        s[n++]='#';
        s[n++]=c;
        c=getchar();
    }
    s[n++]='#';
    maxx = 0;
    //马拉车
    manacher();
    //输出
    cout<<maxx<<endl;
}

封面图来源: 这里

c++语法知识点

Tue, 10 Jan 2023 00:00:00 GMT

c++程序设计

by：小鸭呀

来源：信息学奥赛一本通+菜鸟教程+oiwiki+我的脑袋

本文章遵循cc协议，转载请署名

对于本文章的建议或纠错可以发表评论哦（=^^）

[TOC]

（如果支持的话应该上面会显示个目录）

让程序不闪退的神奇代码

system("pause")版本4.99以前

getchar() 约等于 system("pause")

注释

//这是一行注释
/*这是有头有尾的注释*/

标识符

含义：标识实体（变量名，函数名，对象名）

由大小写字母，下划线和数字0~9组成

必须以大小写字母和下划线开头

运算符

啥子运算符	干啥的	长啥样
算数运算符	数值运算	+,-,*,/（如果俩操作数是整数，则为整除）,% (俩操作数必须是整数) ,++,--(七种)
关系运算符	比较运算	>,<,==,<=,>=,!=(六种) 返回布尔值
逻辑运算符	逻辑运算	&&,\|\|,!
位操作运算符	二进制运算	&,\|,~（非),^(异或),<<,>>(六种)
赋值运算符	赋值运算	简单赋值(=),复合算数赋值(+=,-=,*=,/=,%=),复合位运算赋值(&=,\|=,^=,<<=,>>=)三类共十一种
条件运算符	条件求值	条件?结果a:结果b 条件成立，用结果a，否则用结果b
逗号运算符	把若干个表达式组合成一个表达式	,
指针运算符	取内容，取地址	取内容(*),取地址(&)
求字节数运算符	数据类型所占字节数	sizeof(数据类型)
特殊运算符	玛卡巴卡	( ) [ ] . ->

优先级

自己打括号

常用库函数

依赖cmath库：

格式	功能
abs(x)/fabs(x)	绝对值
exp(x)	e的x次方
floor(x)	向下取整
ceil(x)	向上取整
log(x)	x的自然对数
pow(x,y)	x的y次方
sqrt(x)	根号
round(x)	四舍五入
sin,cos,tan,acos,asin,atan	三角函数

依赖cstdlib库

格式	功能
rand()	0到RAND-MAX之间随机取一个整数

依赖ctime库

格式	功能
clock()	返回程序从开始运行了多少秒

依赖algorithm库

格式	功能
sort(a,a+n,cmp)	对长度为n的a数组排序，用cmp方法

常量

定义常量

#define 变量名数据

const 类型变量名 = 数据;

常量初始化后不可以改变

整型常量

十进制形式

如：99，-1

八进制形式

0开头

如：012

十六进制形式

0x开头

如：0x12A

变量

int i = 5,j,k(5); //i，j，k为整型变量，i，k是5，j未知

a = b = c = 2 等同于 c = 2;b = c;a = b;

标准数据类型

整型与实型

数据类型	定义标识符
短整型	short [int]
整型	[long] int
长整型	long [int]
超长整型	long long [int]
无符号整型	unsigned [int]
无符号短整型	unsigned short [int]
无符号长整型	unsigned long [int]
无符号超长整型	unsigned long long
单精度实型	float
双精度实型	double
长双精度实型	long double
布尔	bool
枚举类型	enum

注:科学计数法是指数形式的表示方法，十进制小数E整数指数，例如 $$ 1.2\times10^5 $$ 就是1.2E+5

枚举类型

enum 枚举名{
	标识符,标识符,标识符(=整型常数)
} 枚举变量;
//举个栗子
enum food{drink,eat=5}c;
c=drink;

重定义数据类型

typedef int metre;

转义字符

转义字符	含义
\b	退格
\r	不换行的回车
\0	空
\n	回车

char类型里+32是大写转小写，-32是小写转大写

强制类型转换：类型名（被转换的可怜变量）

输入输出

事先说明：

#include<iostream>
#include<cstdio>       //这个章节的内容必须有这些语句
using namespace std;

cout用小于，cin用大于

getchar

输入单个字符，无参

char ch;ch=getchar();

putchar

输出单个字符，有参

putchar(66) 根据ASCII码66是字符B，输出B

cout

setw

要导入iomanip库

#include<iomanip>
cout<<setw(6)<<a;

setw控制输出的宽度

cstdio 库

输入

scanf("%类型",&变量名)

格式符：

格式符	说明
d，i	十进制整数
u	无符号十进制整数
o	八进制整数
x	十六进制整数
c	单个字符
s	字符串（非空格开始，空格结束）
f，e	实数

附加格式说明符：

附加格式	说明
l（L字母）	长整型或double型
h	短型数
域宽（一个整数）	输入多少东西
*	不赋值给变量

scanf("%4d,%4d",&a,&b);

cout<<a<<','<<b<<endl;

如果输入的是12345678，则输入为1234,5678

scanf有返回值！！！！！

返回了成功读取的变量的个数哦！！！

while(scanf("%d",&x) != EOF){
	语句
}

如果成功读取，就执行语句

输出

printf(格式控制符,输出列表)

格式符

格式符	说明
d或i	十进制整数
u	无符号十进制整数
x或X	十六进制无符号整数（没有前导符0x）
o	八进制无符号整数（没有前导符0）
c	字符
s	字符串
f	单、双精度小数，一般6位
e或E	单、双精度以指数形式输出小数，一般6位

d格式符

参数	说明
d	数字本身长度
md	输出m位
-md	同上，但左对齐
ld	长整型
mld	输出m位，左补空格
0md或0mld	位数不足m位补0

f格式符

参数	说明
f	实数格式，小数6位
m.nf	总位数m（含小数点），n位小数
-m.nf	同上，左对齐

s格式符

参数	说明
s	字符串
ms	指定宽度m
-ms	同上，左对齐
m.ns	输出m个字符位置，字符数最多n个
-m.ns	同上，左对齐

分支

if

//基本
if(条件){
	主体;
}

//if...else
if(条件){
	主体1;
} else {
	主体2;
}

//else if
if (条件1) {
	主体1;
} else if (条件2) {
	主体2;
} else if (条件3) {
	主体3;
} else {
	主体4;
}

switch

case后面要加break哦

//实例
switch (a){
    case 1:{
        xxx;
        break;
    }
    case 2:{
        xxx;
        break;
    }
    default :{
        xxx;
    }
}

循环

for

for(初始化;条件;更新){
	循环体;
}

while

while(条件){
	循环体;
}

do...while

do {
	循环体;
} while (条件);

break 和 continue

break跳出循环，continue结束本次循环，前往下次循环

数组

初始化：

int a[5] = {1,2,3,4,5}   //初始化
int a[5] = {}      //初始化为0
int a[5] = {1,2}   //初始化为1,2,0,0,0
//读取
a[i];

复制

#include<cstring>
memcpy(b,a,sizeof(a))   //a复制到b
memcpy(b,a,sizeof(/*a的数据类型*/)*k)   //a复制k个元素到数组b

清零

#include<cstring>
int a[5];
memset(a,0/*除了str类型的数组其它只能为0和-1*/,sizeof(a))    //清零

二维数组

数组的数组

格式

数据类数组名 [常量表达式1] [常量表达式2]

创造后为：常量表达式1行，常量表达式2列

程序运行时间

#include<ctime>
#include<iostream>
using namespace std;
int main(){
    ...代码
    cout<<clock()/CLOCKS_PER_SEC<<endl;   //输出用时
}

字符类型、字符数组和字符串

序号	函数 & 目的
1	strcpy(s1, s2); 复制字符串 s2 到字符串 s1。
2	strcat(s1, s2); 连接字符串 s2 到字符串 s1 的末尾。连接字符串也可以用 + 号，例如: `string str1 = "runoob"; string str2 = "google"; string str = str1 + str2;`
3	strlen(s1); 返回字符串 s1 的长度。
4	strcmp(s1, s2); 如果 s1 和 s2 是相同的，则返回 0；如果 s1<s2 则返回值小于 0；如果 s1>s2 则返回值大于 0。
5	strchr(s1, ch); 返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。
6	strstr(s1, s2); 返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。

字符类型

一个字符

字符数组

装字符的数组

输入

gets(字符串名称);

getchar(); //返回字符，回车后才输入

只能输入一个字符串！！！

输出

puts(字符串名称);

putchar(一个字符);

输入后会自动换行

字符串

结尾为”\0“，不计入字符串的实际长度

字符串的输入输出

cin：输入、忽略开头的制表符、换行符、空格。遇到空格或换行停止（不会读取空字符）

getline：输入、直接读取一行内所有内容，包括空格。格式为getline(cin,字符串变量)

字符串的常用操作

字符串s的操作	意义
s.empty()	s空？返回true否则false
s.size()	s中字符个数
s[i]	s中第i个，从0开始
s1+s2	连接s1和s2
s1=s2	s1替换为s2的副本
s1==s2	一样true，否则false
!=,<,<=,>,>=	原意，不变
s.insert(pos,s2)	s里面pos位置前插入s2
s.substr(pos,n)	返回从pos起的n个字符，返回string
s.erase(pos,n)	删除从pos起的n个字符
s.replace(pos,n,s2)	替换从pos起的n个字符为s2
s.find(s2,pos)	寻从pos下标起查找s2第一次出现的位置，找不到返回string::npos
s.c_str	返回与s内容相同的C语言风格的字符串临时指针
sscanf(s,"%d",%N)	约等于n=int(s)
sprintf(s,"%d",N)	约等于s=str(n)
s.substr(2,4)	python中s[2,2+4-1]

字典序

定义

从前往后，挨个比较。第i不同，用i比较。如果相等，谁长谁大。一样的话，相等。

方法

s1.compare(s2)

如果相等返回0，s1小于s2返回小于0，s1大于s2返回大于0

注意

字符串和字符数组的区别在于字符串的结尾是'\0'

函数

定义

void swap(int &a,int &b);//声明
//主体
void swap(int &a,int &b){
    int tmp = a;a = b;b = tmp;
}

传址调用

匿名函数

[闭包](参数){函数体}                 //不指定返回值类型
[闭包](参数) -> 返回值类型 {函数体}   //指定返回值类型

闭包

[]        //未定义变量.试图在Lambda内使用任何外部变量都是错误的.
[x, &y]   //x 按值捕获, y 按引用捕获.
[&]       //用到的任何外部变量都隐式按引用捕获
[=]       //用到的任何外部变量都隐式按值捕获
[&, x]    //x显式地按值捕获. 其它变量按引用捕获
[=, &z]   //z按引用捕获. 其它变量按值捕获
//来源:https://www.cnblogs.com/pzhfei/archive/2013/01/14/lambda_expression.html

文件操作

freopen

需要导入cstdio库

#include<cstdio>
freopen("in.txt","r",stdin);
freopen("out.txt","w",stdout);
fclose(stdin);fclose(stdout);/*
freopen("CON","r",stdin);
freopen("CON","w",stdout);*/

fopen

fopen版本

//定义文件指针
FILE *fin,*fout;
fin=fopen("in.txt","rb");
fout=fopen("out.txt","wb");
fscanf(fin,"%d",&temp);
fprintf(fout,"%d\n",sum);
fclose(fin);fclose(fout);
//切换回标准输入输出
fin=stdin;
fout=stdout;
fscanf(fin,"%d",&temp);
fprintf(fout,"%d\n",sum);

流

#include<cstdio>
#include<fstream>
ifstream fin("haoye.in");//定义输入流fin
ofstream fout("huaiye.out");//定义输出流fout
int main(){
	//fin输入，fout输出，用法和cin，cout一样
	fin.close();
	fout.close();
	return 0;
}

结构体

建立

struct 名字 {
	类型名 变量名;
	结构体名字指针 变量名;
} 变量名;

访问

名字.元素
指针->元素
(*指针).元素

指针

定义和运算

说明	样例
定义：类型 *变量名	int a=10;int *p;
取地址运算符：&	p = &a;
间接运算符：*	*p = 20;

指针可以和整数加减，每加一，偏移一个类型的长度

初始化

方法	说明
int *p = NULL;	声明零指针
int a;int *p=&a;	p初始化为a的地址
int *p = new(int);	申请一个空间给p，*p内容不确定

无类型指针

void *p;
int a = 10;
p = &a;
cout<<*(int*)p<<endl;

指针作为函数参数

void swap(int *x,int *y){
	int t=*x;
	*x=*y;
	*y=t;
}

函数指针

int t(int a){
	return a;
}
int main(){
	cout<<t<<endl;
    int (*p)(int a);//定义函数指针变量,不能写成*p(int a)
    p=t;
    cout<<p(5)<<","<<(*p)(10)<<endl;
    return 0;
}

还有一种定义的方法

void t1(){cout<<"1";}
void t2(){cout<<"2";}
void t3(){cout<<"3";}
void t4(){cout<<"4";}
int sum(int a,int b){return a+b;}
typedef int (*LP)(int,int);
typedef void(*aa)();
int main(){
    aa a[]={t1,t2,t3,t4}
    a[1]();   //输出2
    LP p = sum;
    cout<<p(2,5);     //返回7
}

结构体指针

struct a{
    float b;
} *p;//这个可以
a *p;//这个也行
//应用结构体指针变量
p->b
(*p).score

动态

int *p = new int(1234);
delete p;
int *p = new int[114514];
delete[] p;

类（oop）

//基本：
class 类名{
	//访问修饰符：private/public/protected
    //变量
    //方法
    返回类型 operator/*跟上要改的运算符号*/(参数){
        阿巴阿巴;
    };
    virtual int haoye(){//调用函数的时候都用子类的，不用这个函数
        ;
    }
};
//派生类
class 好耶 : public/*访问修饰符*/ 坏耶 ,其他父类...{
    阿巴阿巴;
    int haoye(){
        ;
    }
};