1
2
3
4
5
6
7

#include <iostream> //头文件
using namespace std; //命名空间——std就是standard标准的意思（不过某些人不推荐这么写，但是std::也是很麻烦的）
int main(){//注意不要写成mian[doge]
    cout << "hello,world!" << endl; // endl作为换行使用
    cin.get(); // 避免程序一闪而过，常见如system("pause")，getchar()，但是在oj上不能写哦！还有是使用古董dev c++的时候会贴心的帮你自动暂停哦。
    return 0; //返回0作为程序正常运行
}

1
2
3
4
5
6
7

int main(){

}
int main()
{

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

#include <iostream>
#include <string> //#include <cstring>
using namespace std;
int main(){
  string a,b,c; //必须先声明变量
  cin >> a;
  cout << a << endl;
  cin >> b >> c;
  cout << b << c;
  system("pause");
}

1
2
3
4

int c;
while((c = cin.get()) != EOF) {
	do something;
}

1
2
3
4

char c;
while(scanf("%c",&c) != EOF) {
	do something;
}

1
2
3
4
5
6

类型 变量名 (,变量名,变量名,……);
int a,b,c,d,e,f;
float b;
string abc,woc;//#include <string>
bool haha,xixi;
int a=1,b=2,c=3,d;//还可以同时分别赋值

1

extern 类型 变量;

1
2

int a = 1;
float b = 2.33;

1
2
3
4
5
6
7

85         // 十进制
0213       // 八进制 
0x4b       // 十六进制 
30         // 整数 
30u        // 无符号整数 
30l        // 长整数 
30ul       // 无符号长整数 

1
2
3
4
5

3.14159       // 合法的 
314159E-5L    // 合法的 
510E          // 非法的：不完整的指数
210f          // 非法的：没有小数或指数
.e55          // 非法的：缺少整数或分数

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

一. string的构造函数的形式：
string str：生成空字符串

string s(str)：生成字符串为str的复制品

string s(str, strbegin,strlen)：将字符串str中从下标strbegin开始、长度为strlen的部分作为字符串初值

string s(cstr, char_len)：以C_string类型cstr的前char_len个字符串作为字符串s的初值

string s(num ,c)：生成num个c字符的字符串

string s(str, stridx)：将字符串str中从下标stridx开始到字符串结束的位置作为字符串初值

eg:


    string str1;               //生成空字符串
    string str2("123456789");  //生成"1234456789"的复制品
    string str3("12345", 0, 3);//结果为"123"
    string str4("012345", 5);  //结果为"01234"
    string str5(5, '1');       //结果为"11111"
    string str6(str2, 2);      //结果为"3456789"
二. string的大小和容量：

1. size()和length()：返回string对象的字符个数，他们执行效果相同。

2. max_size()：返回string对象最多包含的字符数，超出会抛出length_error异常

3. capacity()：重新分配内存之前，string对象能包含的最大字符数
三. string的字符串比较：
    
1. C ++字符串支持常见的比较操作符（>,>=,<,<=,==,!=），甚至支持string与C-string的比较(如 str<”hello”)。  
在使用>,>=,<,<=这些操作符的时候是根据“当前字符特性”将字符按字典顺序进行逐一得 比较。字典排序靠前的字符小，  
比较的顺序是从前向后比较，遇到不相等的字符就按这个位置上的两个字符的比较结果确定两个字符串的大小(前面减后面)
同时，string (“aaaa”) <string(aaaaa)。    

2. 另一个功能强大的比较函数是成员函数compare()。他支持多参数处理，支持用索引值和长度定位子串来进行比较。 
  他返回一个整数来表示比较结果，返回值意义如下：0：相等 1：大于 -1：小于 (A的ASCII码是65，a的ASCII码是97)
五、string拼接字符串：append() & + 操作符
    
void test5()
{
    // 方法一：append()
    string s1("abc");
    s1.append("def");
    cout<<"s1:"<<s1<<endl; // s1:abcdef

    // 方法二：+ 操作符
    string s2 = "abc";
    /*s2 += "def";*/
    string s3 = "def";
    s2 += s3.c_str();
    cout<<"s2:"<<s2<<endl; // s2:abcdef
}

六、 string的遍历：借助迭代器 或者 下标法
void test6()
{
    string s1("abcdef"); // 调用一次构造函数

    // 方法一： 下标法

    for( int i = 0; i < s1.size() ; i++ )
    {
        cout<<s1[i];
    }
    cout<<endl;

    // 方法二：正向迭代器

    string::iterator iter = s1.begin();
    for( ; iter < s1.end() ; iter++)
    {
        cout<<*iter;
    }
    cout<<endl;

    // 方法三：反向迭代器
    string::reverse_iterator riter = s1.rbegin();
    for( ; riter < s1.rend() ; riter++)
    {
        cout<<*riter;
    }
    cout<<endl;
}

八、 string的字符替换：

1. string& replace(size_t pos, size_t n, const char *s);//将当前字符串

从pos索引开始的n个字符，替换成字符串s

2. string& replace(size_t pos, size_t n, size_t n1, char c); //将当前字符串从pos索引开始的n个字符，替换成n1个字符c

3. string& replace(iterator i1, iterator i2, const char* s);//将当前字符串[i1,i2)区间中的字符串替换为字符串s

string的大小写转换：
#include <iostream>
#include <algorithm>
#include <string>

using namespace std;

int main()
{
    string s = "ABCDEFG";
    string result;

    transform(s.begin(),s.end(),s.begin(),::tolower);
    cout<<s<<endl;
    return 0;
}

 string的查找：find
1. size_t find (constchar* s, size_t pos = 0) const;

  //在当前字符串的pos索引位置开始，查找子串s，返回找到的位置索引，

    -1表示查找不到子串

2. size_t find (charc, size_t pos = 0) const;

  //在当前字符串的pos索引位置开始，查找字符c，返回找到的位置索引，

    -1表示查找不到字符

3. size_t rfind (constchar* s, size_t pos = npos) const;

  //在当前字符串的pos索引位置开始，反向查找子串s，返回找到的位置索引，

    -1表示查找不到子串

4. size_t rfind (charc, size_t pos = npos) const;

  //在当前字符串的pos索引位置开始，反向查找字符c，返回找到的位置索引，-1表示查找不到字符

5. size_tfind_first_of (const char* s, size_t pos = 0) const;

  //在当前字符串的pos索引位置开始，查找子串s的字符，返回找到的位置索引，-1表示查找不到字符

6. size_tfind_first_not_of (const char* s, size_t pos = 0) const;

  //在当前字符串的pos索引位置开始，查找第一个不位于子串s的字符，返回找到的位置索引，-1表示查找不到字符

7. size_t find_last_of(const char* s, size_t pos = npos) const;

  //在当前字符串的pos索引位置开始，查找最后一个位于子串s的字符，返回找到的位置索引，-1表示查找不到字符

8. size_tfind_last_not_of (const char* s, size_t pos = npos) const;

 //在当前字符串的pos索引位置开始，查找最后一个不位于子串s的字符，返回找到的位置索引，-1表示查找不到子串

void test10()
{
    char str[] = "I,am,a,student; hello world!";

    const char *split = ",; !";
    char *p2 = strtok(str,split);
    while( p2 != NULL )
    {
        cout<<p2<<endl;
        p2 = strtok(NULL,split);
    }
}

https://blog.csdn.net/qq_37941471/article/details/82107077

1
2
3
4
5
6

struct T{
    int a,b;
    bool operator< (const T &x)const{
        return a<x.a;
    }
}

1
2
3
4

*p;
//*p可以读取从地址P开始的sizeof(T)个字节,T为指针变量的类型，即为声明指针时候的Type
&x;
//&x就是变量x的地址，可以赋值给指针变量

1

(i>>n)&1;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

for(int i = 0; i < (1 << n); i++) //从0～2^n-1个状态
{
        for(int j = 0; j < n; j++) //遍历二进制的每一位
        {
            if(i & (1 << j))//判断二进制第j位是否存在
            {
                printf("%d ",j);//如果存在输出第j个元素
            }
        }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

#include <iostream>
#include <algorithm>
#include <string>
#define MAX 306
int a[MAX],b[MAX],c[MAX];
using namespace std;
int main(){
	string A,B;
	cin >> A >> B;
	int lena=A.length();
	int lenb=B.length();
	// 使用字符串读入两个大数
	for(int i=lena-1,j=0;i>=0;i--,j++){
		a[i]=A[j]-'0';
	}
	for(int i=lenb-1,j=0;i>=0;i--,j++){
		b[i]=B[j]-'0';
	}
	//将大数存在数组当中
	int len=max(lena,lenb);
	//确认和的长度，如果第一位相加大于10，后续还需要加1
	int sum;
	for(int i=0;i<=len-1;i++){
		sum=a[i]+b[i];
		c[i]=sum%10;
		c[i+1]=sum/10;
	}
	//竖式计算
	if(c[len])    //除了0之外全是真
		len++;
	//如果进位，长度加一
	for(int i=len-1;i>=0;i--){
		cout << c[i];
	}	
	//进行输出 
	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

int fp(int a,int b)//fast power
{
    int res=1;
    a=a%mod;
    while(b)
    { 
        if(b&1) res=(res*a)%mod;
        a=(a*a)%mod;
        b>>=1;
    }
    return res;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

int prime[n];
void divide(int n) {
    for(int i = 2; i <= n / i; i++) {
        if(n % i == 0) {
            while(n % i == 0) {
                primes[i]++;
                n /= i;
            }
        }
    }
    if(n > 1) {//质数本身是自己的质因数
        primes[n]++;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

#include <cstdio>
#include <algorithm>

using namespace std;

const int N = 1e6+6;
int h[N], size;

void up(int x){
    while(x / 2 && h[x] < h[x/2]){
        swap(h[x], h[x/2]);
        x /= 2;
    }
}

void down(int u)
{
    int t = u;
    if (u * 2 <= size && h[u * 2] < h[t]) t = u * 2;
    if (u * 2 + 1 <= size && h[u * 2 + 1] < h[t]) t = u * 2 + 1; //注意此处是h[t],所以确保最终t为最小子树节点
    if (u != t)
    {
        swap(h[u], h[t]);
        down(t);
    }
}


int main(){
    int n, op, x;
    scanf("%d", &n);
    while (n--)
    {
        scanf("%d", &op);
        switch (op)
        {
        case 1:
            scanf("%d", &x);
            h[++size] = x;
            up(size);
            break;
        
        case 2:
            printf("%d\n", h[1]);
            break;
        
        case 3:
            h[1] = h[size];
            size --;
            down(1);
            break;

        }

    }
    
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

#include <iostream>

using namespace std;

const int N = 1e5;
int head[N], nxt[N], to[N], w[N], idx;
/*
head[i] 最后一个以i为起点的边的下标
nxt [i]  同一起点的边，以i为下标的下一条边
to 以i为下标的边指向的点
w[i] 权重
idx 分配给边的地址,从1 ~ m
*/

void add(int u, int v, int weight = 0){
    to[++idx] = v;
    w[idx] = weight;
    nxt[idx] = head[u];
    head[u] = idx;
}

bool find_edge(int u, int v){
    for(int i = head[u]; i; i = nxt[i]){
        if(to[i] == v)
            return true;
    }
    return false;
}

int main(){
    int n, m;
    cin >> n >> m;

    for(int i = 1; i <= m; i++){
        int u , v;
        cin >> u >> v;
        add(u, v);
    }

    while(cin >> n && n != 114514){
        int u, v;
        cin >> u >> v;
        cout << find_edge(u, v) << endl;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N = 505;
int g[N][N], d[N], n, m, src; //邻接矩阵存图
bool s[N]; //是否确认最短

void dijkstra() {
    memset(d, 0x3f, sizeof d);
    d[src] = 0;
    for(int k = 1; k < n; k++) { //只是一个无情的计数器,由于源点是手动插入的所以少循环一次
        int t = 0;

        for(int i = 1; i <= n; i++)
            if(!s[i] && (t == 0 || d[i] < d[t])) 
                t = i;
        s[t] = true;

        //从t更新 
        for(int  i = 1; i <= n; i++)
            d[i] = min(d[i], d[t] + g[t][i]);
    }
}

int main() {
    //freopen("tmp.in", "r", stdin);
    int a, b, c;
    scanf("%d%d%d", &n, &m, &src);

    //init
    memset(g, 0x3f, sizeof g);
    for(int i = 1; i <= m; i++) {
        scanf("%d%d%d", &a, &b, &c);
        g[a][b] = min(g[a][b], c);
    }

    dijkstra();

    for(int i = 1; i <= n; i++) cout << d[i] <<" ";
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

#include <iostream>
#include <queue>
#include <cstring>
#include <algorithm>

using namespace std;

typedef pair<int,int> PII;
int n, m, src;
const int N = 2e5+6;
int head[N], to[N], w[N], ne[N], idx;
bool vis[N];
int dist[N];

void add (int a, int b, int c) {
    to[++idx] = b;
    w[idx] = c;
    ne[idx] = head[a];
    head[a] = idx;
}

void dijkstra() {
    memset(dist, 0x3f, sizeof dist);
    dist[src] = 0;

    priority_queue<PII, vector<PII>, greater<PII> > q;
    //greater运算符重载是按照pair的第一个关键词排序的——所以后面的插入元素必须是距离+节点编号

    q.push({0, src});

    while(q.size()) {
        auto t = q.top();
        q.pop();
        int dest = t.second, distance = t.first;

        if(vis[dest])continue;
        vis[dest] = true;

        for(int i = head[dest]; i; i = ne[i]) {
            int j = to[i];
            if(dist[j] > distance + w[i]) {
                dist[j] = distance + w[i];
                q.push({dist[j], j});
            }
        }

    }
}

int main(){
    //freopen("tmp.in", "r", stdin);
    cin >> n >> m >> src;

    for(int i = 1; i <= m; i++){
        int a, b ,c;
        cin >> a >> b >> c;
        add(a,b,c);
    }

    dijkstra();

    for(int i = 1; i <=n ; i++){
        if(dist[i] != 1061109567)
            cout << dist[i] <<" ";
        else
            cout << "2147483647 " ;
    }
}