• 个人简介

    4225 4248 4400 - 4449 ok

    • 设 f,wf,w 两个数列，一个正整数 n(4≤n)n(4\le n)

    • ww 这个数列要求 wiw_i 为完全平方数，wiw_i 顺序递增 (4≤wi≤n)(4\leq w_i \leq n)

    • ff 这个数列要求 $f_i {\ne} w_i \times x(1 \le x \le {\frac{n}{w_i}})$，xx 为正整数，fif_i 顺序递增 (2≤fi≤n,nfi≥1)(2\leq f_i \leq n,\cfrac{n}{f_i} \ge 1)

    比如 1∼101 \sim 10 内的 f,wf,w 两个数列

    w1=4w_1 = 4\\ w2=9w_2 = 9\\

    f1=2f_1 = 2\\ f2=3f_2 = 3\\

    求 $⌊ {\cfrac{n}{(f_1)^2}⌋+⌊\cfrac{n}{(f_2)^2}⌋+\cdots+⌊\cfrac{n}{(f_k)^2}⌋}$ 的值

    lazy 标记的标程lazy\ 标记的标程

    a6133f4db01b4b229d613cb4ffcf9360.jpeg (1080×720) (hysbz.com) [](201909261555108075.png (520×755) (hysbz.com))

    
#define ls num + num
#define rs num + num + 1
int p[N], sum[N << 2], tag[N << 2];
void update(int num) { sum[num] = sum[ls] + sum[rs]; }
void build(int num, int l, int r)
{
    tag[num] = 0;
    if (l == r)
    {
        sum[num] = p[l];
        return;
    }
    int mid = (l + r) >> 1;
    build(ls, l, mid);
    build(rs, mid + 1, r);
    update(num);
}
void push_up(int num, int l, int r, int val)
{
    tag[num] += val;
    sum[num] += val * (r - l + 1);
}
void push_down(int num, int l, int r)
{
    int mid = (l + r) >> 1;
    push_up(ls, l, mid, tag[num]);
    push_up(rs, mid + 1, r, tag[num]);
    tag[num] = 0;
}
void change(int num, int l, int r, int x, int y, int val)
{
    if (l >= x && r <= y) {push_up(num, l, r, val); return;}
    push_down(num, l, r);
    int mid = (l + r) >> 1;
    if (x <= mid) change(ls, l, mid, x, y, val);
    if (y > mid) change(rs, mid + 1, r, x, y, val);
    update(num);
}
int ask(int num, int l, int r, int x, int y)
{
    int ans = 0;
    if (l >= x && r <= y) return sum[num];
    int mid = (l + r) >> 1;
    push_down(num, l, r);
    if (x <= mid) ans += ask(ls, l, mid, x, y);
    if (y > mid) ans += ask(rs, mid + 1, r, x, y);
    return ans;
}

int n, Q;
main()
{
    return 0;
}

    优化大礼包优化大礼包

    #include <bits/stdc++.h>
using namespace std;
//如果 [Compile Error]，删掉前四排。
#include<immintrin.h>
#include<emmintrin.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native")
#pragma GCC optimize(2) 
#pragma GCC optimize(3) 
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline") 
#pragma GCC optimize("-fgcse") 
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow") 
#pragma GCC optimize("-falign-functions") 
#pragma GCC optimize("-fcse-skip-blocks") 
#pragma GCC optimize("-fcse-follow-jumps") 
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining") 
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")

inline char gc()
{
    static char buf[1 << 20/*这里很玄学，改成其他数字可能更快*/], *p1 = buf, *p2 = buf;
    return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 20/*改成和上面一样的数字*/, stdin), p1 == p2) ? EOF : *p1 ++;
}

inline void read(int &n) // 用法 read(n);
{
    bool w = 0;
    char c = gc();
    for(; c < 48 || c > 57; c = gc())
        w = c == 45;
    for(n = 0; c >= 48 && c <= 57; c = gc())
        n = n * 10 + c - 48;
    n = w ? -n : n;
}
char buf[1 << 21/*这里很玄学，改成其他数字可能更快*/];
int p1 = -1;
const int p2 = (1 << 21/*这里很玄学，改成其他数字可能更快*/) - 1;
inline void flush(){fwrite(buf, 1, p1 + 1, stdout); p1 = -1;}
inline void pc(const char &x){if(p1 == p2) flush(); buf[++ p1] = x;}
/*
    如果是多组数据
    就是 write(n,'你输出的字符'); flush();
    否则就是在return 0; 前面加上flush();
    如
    flush();
    return 0;
*/
inline void write(int x, char a) // 用法write(n,'你输出的字符');
{
    if(x < 0) pc(45), x = -x;
    char c[11], s = 0;/*Runtime Error改数组大小*/
    for(; x ;) c[s ++] = x % 10, x /= 10;
    if(!s) pc(48);
    for(; s -- ;) pc(c[s] + 48);
    pc(a);
}

main()
{
    int a, b;
    //读入时 ctrl + z读入结束
    //1,单组数据
    read(a); read(b);
    write(a + b, '\n');
    flush();
    return 0;
    //2，多组数据
    while(1)
    {
        read(a); read(b);
        if(a == 0 && b == 0)
            return 0;
        write(a + b, '\n');
        flush();
    }
    return 0;
}

    无注释版无注释版

    #include<immintrin.h>
#include<emmintrin.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native")
#pragma GCC optimize(2) 
#pragma GCC optimize(3) 
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline") 
#pragma GCC optimize("-fgcse") 
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow") 
#pragma GCC optimize("-falign-functions") 
#pragma GCC optimize("-fcse-skip-blocks") 
#pragma GCC optimize("-fcse-follow-jumps") 
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining") 
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
// #define int long long 
inline char gc()
{
    static char buf[1 << 20], *p1 = buf, *p2 = buf;
    return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 20, stdin), p1 == p2) ? EOF : *p1 ++;
}

inline void read(int &n)
{
    bool w = 0;
    char c = gc();
    for(; c < 48 || c > 57; c = gc())
        w = c == 45;
    for(n = 0; c >= 48 && c <= 57; c = gc())
        n = n * 10 + c - 48;
    n = w ? -n : n;
}
char buf[1 << 21];
int p1 = -1;
const int p2 = (1 << 21) - 1;
inline void flush(){fwrite(buf, 1, p1 + 1, stdout); p1 = -1;}
inline void pc(const char &x){if(p1 == p2) flush(); buf[++ p1] = x;}
inline void write(int x, char a)
{
    if(x < 0) pc(45), x = -x;
    char c[11], s = 0;
    for(; x ;) c[s ++] = x % 10, x /= 10;
    if(!s) pc(48);
    for(; s -- ;) pc(c[s] + 48);
    pc(a);
}

    模版模版

    #include <bits/stdc++.h>

using namespace std;

// #define int long long 
#define rep(i, l, r) for(int i = l; i <= r; ++ i)
#define per(i, r, l) for(int i = r; i >= l; -- i)
#define me0(a); memset(a, 0, sizeof a);
#define me3(a); memset(a, 0x3f, sizeof a);
#define PII pair<int, int>
#define il inline

const int INF = 0x3f3f3f3f, MOD = 1e9 + 7;

il void read(int &n)
{
    bool w = 0;
    char c = getchar();
    for(; c < 48 || c > 57; c = getchar())
        w = c == 45;
    for(n = 0; c >= 48 && c <= 57; c = getchar())
        n = n * 10 + c - 48;
    n = w ? -n : n;
}

il void write(int x, char a)
{
    char c[40], s = 0;
    if(x < 0) putchar(45), x = -x;
    for(; x ;) c[s ++] = x % 10, x /= 10;
    if(!s) putchar(48);
    for(; s -- ;) putchar(c[s] + 48);
    putchar(a);
}

// const int MAXN = ;

main()
{
    return 0;
}

    struct TREE
{
    int tr[MAXN];
    int lowbit(int x){return x&-x;}
    void add(int p, int x){for(;p <= n; p += lowbit(p)) tr[p] += x;}
    int ask(int p) 
    {
        int ans = 0;
        for( ;p; p -= lowbit(p)) ans += tr[p]; 
        return ans;
    }
}tree;
    数据结构
    尺取法（双指针算法）
    表达式求值
    单调栈
    并查集（ok） 
    int find(int x)
{
    return fa[x] == x ? x : fa[x] = find(fa[x]);
}

void merge(int a, int b) 
{    
    int x = find(a);    
    int y = find(b);    
    fa[x] = y;
    sz[y] += sz[x];}
}

    </details>

<details>

<summary>单调队列（ok）</summary>

```cpp
for (int i = 0; i < n; ++ i)
    {
        scanf("%d", &a[i]);
        if (i - k + 1 > q[hh]) ++ hh;                 
        while (hh <= tt && a[i] <= a[q[tt]]) -- tt;   
        q[++ tt] = i;                                 
        if (i + 1 >= k) printf("%d ", a[q[hh]]);    
    }
    RMQ（ok） 
    void pre()
{
    int t=log2(n);
    for(int j=1;j<=t;j++)
        for(int i=1;i+(1<<j)-1<=n;i++)
            f[i][j]=max(f[i][j-1],f[i+(1<<(j-1))][j-1]);
}
int query(int l,int r)
{
    int t=log2(r-l+1);
    return max(f[l][t],f[r-(1<<t)+1][t]);
}
int main(){
    cin >> n;
    for(int i=1;i<=n;i++)
        cin>>f[i][0];
    pre();
    cin>>m;
    while(m--)
    {
        int l,r;
        cin>>l>>r;
        cout<<query(l,r)<<endl;
    }
    return 0;
}
    hash
    链表
    单链表
    双链表
    动态规划
    • 背包 DP
      • 01背包
      • 完全背包
      • 多重背包
      • 多重背包
      • 多维背包
      • 混合背包
      • 分组背包
      • 有依赖的背包
    • 线性 DP
    • 区间 DP
    • 树形 DP
    • 状压 DP
    • 数位 DP
    • 动态 DP
    • 记忆化搜索
    • Lis
    • 资源分配
    数论
    质数（ok） 
    bool prime(int n)
{
    if(n < 2) return 0;
    for(int i = 2; i * i <= n; ++ i)
        if(n % i == 0)
            return 0;
    return 1;     
}
    约数（ok）
    试除法求约数 
    vector <int> get_divisorts(int n){ 
    vector <int> res;
    for(int i = 1;i <= n / i;i ++){
        if(n % i == 0){ 
            res.push_back(i); 
            if(i != n / i) res.push_back(n / i); 
        }
    }
    sort(res.begin(),res.end()); 
    return res; 
}
    约数个数 
    int yueshu(int n)
{	
	for (int i = 2; i <= n / i; i ++) {
		int cnt = 1;
		while (n % i == 0) {
			n /= i;
			cnt ++;
		}
		sum *= cnt;
	}
	if (n != 1)
		sum *= 2;
	return sum;
}
    约数之和
    欧拉函数（ok） 
    int oula(int x)
{
	int res = x;
    for (int i = 2; i <= x / i; ++ i) 
    {
        if (x % i == 0) 
        {
            res = res / i * (i - 1);
            while (x % i == 0) 
                x /= i;
        }
    }
    if (x > 1)
        res = res / x * (x - 1);
    return res;
}
    快速幂（ok） 
    int qsm(int a,int b,int p)
{
    int res=1;
    while(b)
    {
        if(b&1) res = res *a %p;
        b>>=1;
        a=a*a%p;
    }
    return res;
}
    扩展欧几里得算法
    求组合数
    埃氏筛（ok） 
    void get_primes(int n) {
    for(int i = 2; i <= n; i++) {
        if(!st[i]){ 
            prime[cnt++] = i;
            for(int j = i; j <= n; j += i)
                st[j] = true;
        }
    } 
}
    欧拉筛
    图论
    拓扑排序
    最小生成树
    Prim
    Kruskal
    最短路
    Floyd 算法（ok） 
    void floyd() {
    for(int k = 1; k <= n; k++)
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
    Bellman-Ford 算法（ok） 
    int bellman_ford() {
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    for (int i = 0; i < k; i++) {
        memcpy(back, dist, sizeof dist);
        for (int j = 0; j < m; j++) {
            int a = e[j].a, b = e[j].b, w = e[j].w;
            dist[b] = min(dist[b], back[a] + w);
        }
    }
    if (dist[n] > 0x3f3f3f3f / 2) return -1;
    else return dist[n];

}
    SPFA算法（ok） 
    int spfa(){
    queue<PII> q;
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    q.push({0,1});
    st[1]=true;
    while(q.size()){
        PII p=q.front();
        q.pop();
        int t=p.se;
        st[t]=false;
        for(int i=h[t];i!=-1;i=ne[i]){
            int j=e[i];
            if(dist[j]>dist[t]+w[i]){
                dist[j]=dist[t]+w[i];
                if(!st[j]){
                    st[j]=true;
                    q.push({dist[j],j});
                }
            }
        }
    }
    if(dist[n]==0x3f3f3f3f) return -1;
    else return dist[n];
}
    Dijkstra 算法
    vector 建树 
    struct EDGE{int son, val;}edge;
vector <EDGE> V[MAXN];
inline void add(int x, int y, int z)
{ 
    V[x].push_back({y, z});
}

    struct EDGE{int son;}edge;
vector <EDGE> V[MAXN];
inline void add(int x, int y)
{ 
    V[x].push_back({y});
}

    {
    "shell_cmd": "g++ \"${file}\" -o \"${file_path}/${file_base_name}\" -Wall -std=c++11 -Wextra -g",
    "file_regex": "^(..[^:]*):([0-9]+):?([0-9]+)?:? (.*)$",
    "working_dir": "${file_path}",
    "selector": "source.c, source.c++",
 
    "variants":
    [
        {
            "name": "Run",
            "shell_cmd" : "start cmd /c \"\"${file_path}/${file_base_name}\" & pause\""
        },
        {
            "name": "RunInCommand",
            "shell_cmd" : "g++ \"${file}\" -o \"${file_path}/${file_base_name}\" -Wall -std=c++11 -Wextra -g && start cmd /c \"\"${file_path}/${file_base_name}\" & echo.                                & echo -------------------------------- & echo Process exited after seconds with return value 0 & pause\""
        },
        {
            "name": "Debug",
            "shell_cmd" : "start cmd /c \"gdb \"${file_path}/${file_base_name}\"\""
        }
    ]
}

    {
	"auto_complete": false,
	"ignored_packages":
	[
		"Vintage",
	],
}

    秋风落日入长河 江南烟雨行舟  

乱石穿空 卷起多少的烽火

万里山河都踏过 天下又入谁手 

分分合合 不过几十载春秋 

我在 十面埋伏 四面楚歌的时候  

把酒与苍天对酌  

纵然一去不回 此战又如何  

谁见 万箭齐发 星火漫天夜如昼  

刀光剑影交错  

而我枪出如龙 乾坤撼动 一啸破苍穹  

长枪刺破云霞 放下一生牵挂  

望着寒月如牙 孤身纵马 生死无话  

风卷残骑裂甲 血染万里黄沙  

成败笑谈之间 与青史留下  

我在 十面埋伏 四面楚歌的时候  

把酒与苍天对酌 

纵然一去不回 此战又如何  

谁见 万箭齐发 星火漫天夜如昼  

刀光剑影交错  

而我枪出如龙 乾坤撼动 一啸破苍穹  

长枪刺破云霞 放下一生牵挂  

望着寒月如牙 孤身纵马 生死无话  

风卷残骑裂甲 血染万里黄沙  

成败笑谈之间 与青史留下  

长枪刺破云霞 放下一生牵挂  

望着寒月如牙 孤身纵马 生死无话  

风卷残骑裂甲 血染万里黄沙  

笑谈间 谁能留下

    我饮过风 咽过沙

浪子无钱逛酒家

闻琵琶 谁人画

不再春风如寒鸦

我饮过风 咽过沙

浪迹天涯浮云下

叹流年 似黄花

问过苍天无人答

我饮过风 咽过沙

浪子无钱逛酒家

闻琵琶 谁人画

不再春风如寒鸦

我饮过风 咽过沙

浪迹天涯浮云下

叹流年 似黄花

问过苍天无人答

捻一指流沙 池鱼溅浪花

待我醉马挥剑 斩落晚残霞

梦见紫金甲 头戴凤批纱

黄粱一梦 太虚幻浮夸

聊一篇闲话 布衣越冬夏

待我功成名就 西山纵肥马

凭酒论天下 喊声小二续茶

明月邀窗 故佯装潇洒

我饮过风 咽过沙

浪子无钱逛酒家

闻琵琶 谁人画

不再春风如寒鸦

我饮过风 咽过沙

浪迹天涯浮云下

叹流年 似黄花

问过苍天无人答

我饮过风 咽过沙

浪子无钱逛酒家

闻琵琶 谁人画

不再春风如寒鸦

我饮过风 咽过沙

浪迹天涯浮云下

叹流年 似黄花

问过苍天无人答

聊一篇闲话 布衣越冬夏

待我功成名就 西山纵肥马

凭酒论天下 喊声小二续茶

明月邀窗 故佯装潇洒

我饮过风 咽过沙

浪子无钱逛酒家

闻琵琶 谁人画

不再春风如寒鸦

我饮过风 咽过沙

浪迹天涯浮云下

叹流年 似黄花

问过苍天无人答

我饮过风 咽过沙

浪子无钱逛酒家

闻琵琶 谁人画

不再春风如寒鸦

我饮过风 咽过沙

浪迹天涯浮云下

叹流年 似黄花

问过苍天无人答

我饮过风 咽过沙

浪子无钱逛酒家

闻琵琶 谁人画

不再春风如寒鸦

我饮过风 咽过沙

浪迹天涯浮云下

叹流年 似黄花

问过苍天无人答

我饮过风 咽过沙

浪子无钱逛酒家

闻琵琶 谁人画

不再春风如寒鸦

我饮过风 咽过沙

浪迹天涯浮云下

叹流年 似黄花

问过苍天无人答

    霜月落庭前 照谁一夜无眠

提笔惊扰烛火 回忆难写

看人间故事 都逃不过离别

数不完的阴晴换圆缺

半生风雪 吹不散花落时节的眼泪

唤不回 孤雁终要南飞

心事谁了解 唯有明月来相随

思念予我眉间又几分憔悴

半生风雪 吹不散岁月留下的眼泪

换不回 青丝已尽成灰

结局谁来写 写不完爱恨缠绵

徒我顾影自怜自叹又几遍

霜月落庭前 照谁一夜无眠

提笔惊扰烛火 回忆难写

看人间故事 都逃不过离别

数不完的阴晴换圆缺

半生风雪 吹不散花落时节的眼泪

唤不回 孤雁终要南飞

心事谁了解 唯有明月来相随

思念予我眉间又几分憔悴

半生风雪 吹不散岁月留下的眼泪

换不回 青丝已尽成灰

结局谁来写 写不完爱恨缠绵

徒我顾影自怜自叹又几遍

半生风雪 吹不散岁月留下的眼泪

换不回 青丝已尽成灰

结局谁来写 写不完爱恨缠绵

徒我顾影自怜自叹又几遍
    ```cpp 右键点击“开始”菜单， 选择运行，在运行输入“control”打开控制面板， 我们在控制面板中，点击“网络和internet”选项 再点击“网络和共享中心” 我们点击“以太网”。 在以太网状态界面中，点击“属性”按钮 在以太网属性界面中，我们双击进入internet 协议版本4（TCP/IPv4） internet 协议版本4（TCP/IPv4）属性界面中，点击“使用下面的DNS服务器地址”， 将首选和备用DNS服务器分别设置为“114.114.114.114”，“8.8.8.8”即可解决电脑DNS被劫持的问题。 ``` ### vim的三种模式：

    命令模式、文本模式 、末行模式。

    进入文本模式的各种方式：

    i 进入文本模式，光标前插入字符

            a 进入文本模式，光标后插入字符

            o 进入文本模式，光标所在行的下一行插入

            I 进入文本模式，光标所在行的行首插入

            A 进入文本模式，光标所在行的行末插入字符

            O 进入文本模式，光标所在行的上一行插入字符

            s 删除光标所在字符并进入文本模式

            S 删除光标所在行并进入文本模式

    命令模式下的光标移动：

    h 左移

            j 下移

            k 上移

            l 右移

    跳转到指定行：

    1. 88G 命令模式下按  88G，跳转到88行

            2. :88  (末行模式)     跳转到88行

    跳转到n+1行：命令模式下按   n（n是数字）（如：在命令模式下输入100会跳转到101行）

    跳转文件首： 命令模式下按   gg 

    跳转文件尾：命令模式下按   G

    自动格式化程序：命令模式下按   gg=G

    大括号对应：% （命令模式）（在for{}语句中，把光标移动到{，在命令模式下输入%，会跳转到}，可以判断语句有多少行，，再按%跳回去{。其他括号也可以这样）。

    光标移至行首：命令模式下按   0    执行结束，工作模式不变

    光标移至行尾：命令模式下按   \$    执行结束，工作模式不变

    删除光标至行尾：命令模式下按   D 或者 d\$

    删除光标至行首：命令模式下按   d0 （d：delete）

    删除单个字符：命令模式下按   x 执行结束，工作模式不变。

    替换单个字符：用光标移到将待替换的字符， r （命令模式），再按欲替换的字符

    删除一个单词：dw（命令模式）光标置于单词的首字母进行操作。

    删除指定区域：命令模式下按   V   切换为 “可视模式”，使用 hjkl挪移光标来选中待删除区域。  按 d 删除该区域数据。

    剪切（删除）并且粘贴指定1行：命令模式下在光标所在行，按   dd ，然后选择某一行按   p   粘贴剪切的那一行内容到光标所在的下一行（按P在当前所在行粘贴）。

    剪切（删除）并且粘贴指定N行：在光标所待删除首行，命令模式下在光标所在行，按 Ndd （N是数字），然后选择某一行按   p   粘贴剪切的那N行内容到光标所在的下一行（按P在当前所在行粘贴）。

    复制一行：yy（nyy复制n行）

    粘贴：p：向后、P：向前。

    撤回上一步操作：命令模式下按   u


    查找：
        1. 找 设想内容：命令模式下， 按 “/” 输入欲搜索关键字，回车。使用 n 检索下一个。（如：我想在文本中查找hello这个单词，应该在命令模式下输入：/hello  然后按下回车键，再按下n键查找跳转到下一个hello）

        2. 找 看到的内容：命令模式下，将光标置于单词任意一个字符上，按 “\*”  “#” 。（如：我想在文本中查找hello这个单词，应该在命令模式下，应该把光标移动到hello这个单词中的任意一个字母h、e、l、l、o按下\*查找下一个hello，按下#查找上一个hello）

    替换：

            单行替换：将光标置于待替换行上， 进入末行模式，输入 :s /原数据/新数据。如：:s /printf/println/g

            通篇替换：末行模式， :%s /原数据/新数据/g   g:不加，只替换每行首个。如：:%s /printf/println/g

            指定行的替换：末行模式， :起始行号，终止行号s /原数据/新数据/g   g:不加，只替换每行首个。 如：:29,35s /printf/println/g（把29到35行的所有printf替换成println，不加g就只替换每行首个printf）

    分屏：
            sp：横屏分。 Ctrl+ww 切换。:q   退出

            vsp：竖屏分。Ctrl+ww 切换。:q   退出

    跳转至 man 手册：将光标置于待查看函数单词上，使用 K（命令模式）跳转。 指定卷n， nK

    查看[宏定义](https://so.csdn.net/so/search?q=%E5%AE%8F%E5%AE%9A%E4%B9%89&spm=1001.2101.3001.7020)：将光标置于待查看宏定义单词上，使用 [d 查看定义语句。

    在末行模式执行shell命令：:!命令    如：  :! ls -l

    写完后按Esc键，然后输入：，加上wq就能保存退出了。

    如果强制退出不保存!q回车。

    翻屏 Ctrl+f: 向下翻一屏 Ctrl+b: 向上翻一屏 Ctrl+d: 向下翻半屏 Ctrl+u: 向上翻半屏

    【n】光标向右移动n个字符 【Home】移动到这一行的最前面字符处:0数字，但不能用数字小键盘上的数字 【End】 移动到这一行的最后面字符处:$，我测试好像不行 【w】光标跳到下个字的开头 【e】光标跳到下个字的字尾

    【H】 光标移动到这个屏幕的最上方那一行的第一个字符 【M】 光标移动到这个屏幕的中间那一行的第一个字符 【L】光标移动到这个屏幕的最下方那一行的第一个字符

    【G】 移动到这个文件的最后一行 【nG】移动到这个文件的第n行(可配合:set nu) 【gg】 移动到这个文件的第一行，相当于1G 【n】光标向下移动n行

    【/word】 向光标向下寻找一个名称为word的字符串 【?word】 向光标向上寻找一个名称为word的字符串 【n】 代表重复前一个查找的动作 【N】 与n刚好相反，为【反向】进行行前一个查找动作

    【:n1,n2s/word1/word2/g】 n1与n2为数字，在第n1与n2行之间查找word1 这个字符串，并将该字符串替换为word2

    【:1,$s/word1/word2/g】 从第一行到最后一行查找word1字符串，并将该字符串替换为word2 【:1,$s/word1/word2/gc】 从第一行到最后一行查找word1字符串，并将该字符串替换为word2 ，且在替换前提示用户确认是否进行替换

    一般模式切换到命令行模式可用的按钮说明 【:w】 保存编辑的内容 【:w!】强制写入该文件，但跟你对该文件的权限有关 【:q】 离开vi 【:q!】 不想保存修改强制离开 【:wq】 保存后离开 【:x】 保存后离开 【ZZ】 若文件没有更动，则不保存离开，若文件已经被更改过，则保存后离开

    【:w filename】 将编辑的数据保存成另一个文件（类似另存） 【:r filename】 在编辑的数据中，读入另一个文件的数据。即将【filename】 这个文件的内容加到光标所在行后面。

    【:n1,n2 w filename】 将n1到n2的内容保存成filename这个文件。 【:! command】暂时离开vi 到命令行模式下执行command的显示结果！例如 【:! ls /home】即可在 vi 当中察看/home底下以ls输出的文件信息！

    【:set nu】 显示行号 【:set nonu】 与 set nu 相反，为取消行

    多文件编辑 如果你需要复制一个文件中的某段到另外一个文件中，而vim不能够在关闭的时候，把这段保留住。或者是用其它的方法复制。 【vim file1 file2】

    【:n】编辑下一个文件 【:N】编辑上一个文件 【:files】列出目前这个vim编辑的所有文件

    多窗口功能 有两个需要对照着看的文件 【:sp filename】开启一个新窗口，如果有加 filename， 表示在新窗口开启一个新文件，否则表示两个窗口为同一个文件内容(同步显示)。

    【ctrl+w+j】 【ctrl+w+↓】按键的按法是：先按下 【ctrl】 不放， 再按下 w 后放开所有的按键，然后再按下 j (或向下箭头键)，则光标可移动到下方的窗口。

    【ctrl+w+k】 【ctrl+w+↑】同上，不过光标移动到上面的窗口。

    vim 环境设定与记录(~/.vimrc, ~/.viminfo)

    参数参考文档。

    • 设定自动缩进 :set autoindent :set ai :set noai

    • 查找到的文本高亮显示或取消 :set hlsearch :set nohlsearch

    • 语法高亮 :syntax on :syntax off

    • 显示忽略或区分字符大小写 :set ic :set noic

    • 显示或取消显示行号 :set nu :set nonu

    • 将另外一个文件的内容填充在当前文件中 :r /path/to/somefile

    • 将当前文件中部分内容另存为另外一个文件末行模式下使用w命令 :w /path/to/somewhere :ADDR1,ADDR2w /path/to/somewhere

    • 配置文件（保存退出vim后，在下次使用vim的时候，就会有自己的vim操作环境了。） /etc/vimrc（全局配置有效） ~/.vimrc (当前bash)

      注意;上面的参数参考中每一行前面加不加【:】效果都是一样的。

    i和a

    i：光标所在处前面开始插入

    a：光标所在处后面开始插入

    I和A

    I：光标跳到光标所在行的行首，从行首开始插入

    A：光标跳到光标所在行的行尾，从行尾开始插入

    O和o

    O：从光标所在行上面新插入一行

    o：从光标所在行下面新插入一行

    二、复制粘贴

    复制和粘贴通常一起使用

    复制单行粘贴

    yyp 复制光标所在行全部内容, 在光标的上一行粘贴

    yyP 复制光标所在行全部内容, 在光标的上一行粘贴

    复制多行

    [num]yyp 复制光标所在行及往下的num行全部内容, 在光标的上一行粘贴

    [num]yyP 复制光标所在行及向下的num行全部内容, 在光标的上一行粘贴

    三、删除

    删除单行

    dd：删除光标所在行

    删除多行

    [num]dd:删除光标所在行及向下的num行

    删除全部

    光标移动到开头后，d+shift+g

    四、查找

    /pattern：向下搜索pattern，键盘n跳转下一个pattern

    ?pattern：向上搜索pattern，键盘n跳转上一个pattern

    右下角的pattern位置会变化，”？” 往上查找，”/“向下查找

    底线命令模式

    一、保存退出

    vim插入模式想要退出，需要先按下键盘的“esc”键，然后输入“：”，输入wq（保存退出）或者q!(不保存退出)

    快捷方式退出，按下esc后，ZZ。（shift+z两次）

    二、其他常用

    快速定位到文件开头 gg

    快速切换到文件末尾 shift+g

    撤销上一操作 u

    显示和去显示行号 ：set nu 和 ：set nonu

    多行注释和撤销注释

    ①、注释：

    ctrl + v进入可视块模式

    箭头上下选择行

    shift+i进入插入模式

    输入#

    esc退出则注释完成

    ②、撤销注释

    ctrl + v进入可视块模式，箭头上下选择行，按下键盘“d”,保存退出即可

  • 通过的题目

  • 最近活动

  • 最近编写的题解

    This person is lazy and didn't write any solutions.

  • Stat

  • Rating

103
已递交
89
已通过
0
题解被赞

题目标签

USACO
8
dp
8
各省省选
8
动态规划
7
线段树
7
2009
5
2012
4
2015
4
枚举
4
暴力
4
LCA
3
贪心
3
O2优化
3
POI
3
天津
3
2005
2
2008
2
2013
2
网络流
2
点分治
2
  1. 关于
  2. 联系我们
  3. 隐私
  4. 服务条款
  5. 版权申诉
  6. Language
  7. 兼容模式
  8. 主题
  2. © 2021-2024 Hydro.ac
  4. Worker 0 in 1907ms
  5. Hydro v4.18.0 Professional