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

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

using namespace std;
const int N = 10010;
int n;
int a[N];
int len;
void pop()
{
    swap(a[1],a[len]);
    a[len -- ] = 0;
    int parent = 1;
    int son = 2;
    while(son <= len)
    {
        if(son < len && a[son] > a[son + 1]) son ++;
        if(a[parent] > a[son])
        {
            swap(a[parent],a[son]);
            parent = son;
            son = parent * 2;
        }else break;
    }
}
void push(int x)
{
    a[++len] = x;
    int son = len , parent = son / 2;
    while(a[son] < a[parent] && parent >= 1)
    {
        swap(a[son],a[parent]);
        son = parent,
        parent = son / 2;
    }
}
int main()
{
    int res = 0;
    int x;
    scanf("%d", &n);
    len = 0;
    memset(a,0,sizeof(a));
    for(int i = 1 ; i <= n ; i ++)
    {
        scanf("%d", &x);
        push(x);
    }
    while(len > 1)
    {
        int x,y;
        x = a[1]; pop();
        y = a[1]; pop();
        push(x+y);
        res += x+y;
    }
    printf("%d",res);
    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

#include <iostream>
#include <cstdio>
#include <cstdlib>

using namespace std;
const int N = 11000;
const int M = 110;
int w[N];
int p[M];
int main()
{
    int n,m;
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n ; i ++)
    {
        scanf("%d",&w[i]);
    }
    int ans = 0;
    for(int i = 1; i <= m; i ++)
    {
        p[i] = w[i];
    }
    int next = m + 1;
    while(next <= n + m ) // 此处设置n + m的目的是之后如果所有都完毕后，只需要把当前水量全部流完就行了。当前有m个盆
    {
        for(int i = 1; i <= m; i ++)
        {
            p[i] --;
            if(p[i] == 0)
            {
                p[i] = w[next];
                next++;
            }
        }
        ans++;
    }
    printf("%d", ans);
    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

#include <iostream>
#include <cstdlib>
#include <cstdio>
//特别注意：
//本题的数据量比较大，已经爆int
//因此本题应该采用long long来存储整型数据
using namespace std;
const int N = 100010;
typedef long long LL;
int main()
{
    LL a,b;
    scanf("%lld%lld", &a, &b);
    LL sum = a + b;
    LL n = 0;
    LL i = 1;
    while(1)
    {
        n += i;
        if(n == sum) //只有n == sum的时候才有解，此时的解就是i次
        {
            printf("%lld ",i);
            for(LL j = i; j >= 1; j --)
            {
                if(a == j) 
                {
                    printf("%lld",j);
                    break;
                }
                if(a > j)
                {
                    printf("%lld " ,j);
                    a = a - j;
                }
            }
            break;
        }
        if (n > sum)
        {
            printf("No");
            break;
        }
        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

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>

using namespace std;
const int N = 4010;
int w[N];
int main()
{
    int n;
    scanf("%d", &n);
    int x;
    int temp = 0;
    int ans = 0;
    memset(w, 0, sizeof(w));
    for(int i = 1; i <= n; i ++)
    {
        scanf("%d", &x);
        w[x] ++;
        if(w[x] == 2) temp ++;
        if(temp == 2)
        {
            ans++;
            temp = 0;
            memset(w, 0, sizeof(w));
        }
        if(w[x] == 4)
        {
            ans ++;
            temp = 0;
            memset(w, 0, sizeof(w));
        }
    }
    printf("%d", ans);
    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

#include <bits/stdc++.h>
using namespace std;
const int MAXN=2e5+5;
char s[MAXN];
int n,k,ne[MAXN][3]; 
//ne数组存放删除了多少
int main(){
	scanf("%d%d%s",&n,&k,s+1);
    //s+1目的是为了让字符串从1开始
	int cur=1,num=0;
    //计算"J"有多少个
	while(cur<=n && num<k) num+=(s[cur++]=='J');
    cur--;
	for(int i=1;i<=n+1;i++){
		ne[i][0]=cur;
		if(s[i]=='J'){
			if(cur!=n+1) cur++;
			while(cur<=n&&s[cur]!='J') cur++;
		}
	}
	cur=1,num=0;
	while(cur<=n&&num<k) num+=(s[cur++]=='O');
    cur--;
	for(int i=1;i<=n+1;i++){
		ne[i][1]=cur;
		if(s[i]=='O'){
			if(cur!=n+1) cur++;
			while(cur<=n&&s[cur]!='O') cur++;
		}
	}
	cur=1,num=0;
	while(cur<=n&&num<k) num+=(s[cur++]=='I');
    cur--;
	for(int i=1;i<=n+1;i++){
		ne[i][2]=cur;
		if(s[i]=='I'){
			if(cur!=n+1) cur++;
			while(cur<=n&&s[cur]!='I') cur++;
		}
	}
	int ans=n+1;
	for(int i=1;i<=n;i++){
		int r=ne[i][0];
		if(r!=n+1) r=ne[r+1][1];
		if(r!=n+1) r=ne[r+1][2];
		if(r!=n+1) ans=min(ans,r-i+1-(k*3));
	}
    if(ans == n + 1)
    {
        printf("%d",-1);
    }
    else
    {
        printf("%d",ans);
    }
}

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

#include <iostream>
#include <cstdio>
#include <cstdlib>

using namespace std;
const int N = 1000010;
typedef long long LL;

LL f[N],res[N];
int main()
{
    int n;
    scanf("%d",&n);
    //暴力筛选：目的是求出所有因子
    for(int i = 1; i <= n; i ++)
    {
        for(int j = i; j <= n; j = j + i)
        {
            f[j] = f[j] + i;
        }
    }
    //递推式后一部分就是该数的所有因子的和
    res[1] = 1;
    for(int i = 2; i <= n; i ++)
    {
        res[i] = res[i - 1] + f[i]; //递推式求解
    }
    //👆求出所有θ(X)
    for(int i = 1; i <= n; i ++)
    {
        printf("%lld ",(LL)n*(LL)i - res[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 <bits/stdc++.h>
#include <vector>

using namespace std;
typedef long long LL;
const int N = 5010;
int num[N][5001];
//数组开太大容易MLE
//高精度加法+斐波那契数列
//斐波那契数列的非递归方式
int main()
{
    int n;
    int len = 1;
    scanf("%d",&n);
    num[1][1] = 1; //第1项
    num[2][1] = 2; //第2项
    for(int i = 3; i <= n; i ++) //从第三项开始
    {
        for(int j = 1; j <= len; j ++)
        {
            num[i][j] = num[i - 1][j] + num[i - 2][j]; //模拟斐波那契数列的由来
        }
        for(int j = 1; j <= len; j ++)//高精度加法
        {
            if(num[i][j] >= 10)//如果有一项大于10的话，则进位
            {
                num[i][j+1] += num[i][j] / 10;
                num[i][j] = num[i][j] % 10;
                if(num[i][len+1]) len++; //如果后一位不为0的话，则长度len++
            }
        }
    }
    for(int i = len; i >= 1; i --)//倒序输出
    {
        printf("%d",num[n][i]);
    }
    return 0;
}
/*
//另外的方法，似乎存在错误
//TPDO:废人一个🐻
int main()
{
    LL n;
    scanf("%lld", &n);
	num[1][N-1]=1;//第一项 
	num[2][N-1]=2;//第二项
	for(int i = 3; i <= n; i ++)
	{
		for(int j = N - 1; j >= 0; j --)
		{
			if((num[i-1][j]+num[i-2][j])>=10)
            {
				num[i][j-1]+=1;
            }
			num[i][j]=num[i][j]+(num[i-1][j]+num[i-2][j])%10; 
        } 
    } 
    int j = 0;
    while(num[n][j] == 0) j++;
    for(int i = j; i < N; i++)
    {
        printf("%lld",num[n][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

#include <bits/stdc++.h>
#include <cstring>
using namespace std;
const int N = 210;
int a[N][N];
int s[N][N];
int main()
{
    int n,m;
    scanf("%d%d", &n,&m);
    memset(s,0,sizeof(s));
    for(int i = 1; i <= n; i ++)
    {
        for(int j = 1; j <= m; j ++)
        {
            scanf("%d", &a[i][j]);
        }
    }
    for(int i = 1; i <= n; i ++)
    {
        for(int j = 1; j <= m; j ++)
        {
            s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + a[i][j];
        }
    }
    int ans = 0;

    //DEBUG
    /*
    for(int i = 0 ; i <= n; i ++)
    {
        for(int j = 0; j <= m; j ++)
        {
            cout << s[i][j] << " ";
        }
        cout << endl;
    }
    */
//求正方形边长，不是要你去求面积=c=
    for(int i = 1; i <= n; i ++)
    {
        for(int j = 1; j <= m; j ++)
        {
            int k = i;
            int p = j;
            int res = 0;
            while(k <= n && p <= m)
            {
                res = s[k][p] - s[i - 1][p] - s[k][j - 1] + s[i-1][j-1];
                int temp = (k - i + 1) * (p - j + 1);
                //DEBUG
                //cout << " RES : " << res << endl;
                if (res >= 0 && res == temp)
                {
                    res = sqrt(res); //求正方形边长
                    ans = max(ans, res);
                }
                k++;
                p++;
            }
        }
    }
    printf("%d", ans);
}

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

#include<bits/stdc++.h>
using namespace std;
int i,j,k,m,n;
int ans=2;
int a[10010];
int b[10010];
//只有可能是0,1,2
//从第一个位置开始进行判断
//如果第一个位置有雷和无雷都能满足要求的话，那么ans=2;
//可以设最初ans=2;然后去进行特判。
int main()
{
    cin>>n;
    for (i=1;i<=n;i++)
    {
        cin>>a[i];
    }
    b[1]=1;
    //假设第一个有雷
    for(int i = 2;i <= n+1; i++)
    //从第二个位置开始比较
    {
        b[i] = a[i-1] - b[i-1] - b[i-2];
        if (!(b[i]==1||b[i]==0))
        {
            ans--;
            break;
        }
        if (i==n+1 && b[i]!=0)
        {
            ans--;
            break;
        }
    }
    b[1]=0;
    //假设第一个无雷
    for(int i  =2;i  <=n+1;i ++)
    {
        b[i] = a[i-1] - b[i-1] - b[i-2];
        if (!(b[i] == 1||b[i] == 0))
        {
            ans--;
            break;
        }
        if (i == n+1 && b[i] != 0)
        {
            ans--;
            break;
        }
    }
    cout<<ans;   
    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

#include <bits/stdc++.h>

using namespace std;
const int N = 1010;
int a[N][N];
int s[N][N];
int x;
int y;
int ans = -0x3f3f3f3f;
//4个3f
//要注意题目有可能是最大值是负数，所以初始化可以是负数
int main()
{
    ios::sync_with_stdio(false);
    int n,m,c;
    cin >> n >> m >> c;
    for(int i = 1; i <= n; i ++)
    {
        for(int j = 1; j <= m; j ++)
        {
            cin >> a[i][j];
        }
    }
    for(int i = 1; i <= n; i ++)
    {
        for(int j = 1; j <= m; j ++)
        {
            s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + a[i][j];
        }
    }
    for(int i = 1; i <= n; i ++)
    {
        for(int j = 1; j <= m; j ++)
        {
            int k = i + c - 1;
            int p = j + c - 1;
            //这里要注意是 x + c - 1(要减去1)
            if(k > n || p > m) continue;
            int res = 0;
            res = s[k][p] - s[i - 1][p] - s[k][j - 1] + s[i-1][j-1];
            if(res > ans)
            {
                ans = res;
                x = i;
                y = j;
            }
        }
    }
    cout << x << " " << y;
}

 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

//P3131
#include <bits/stdc++.h>

using namespace std;
const int N = 1000010;
typedef long long LL;

LL s[N];
int main()
{
    int n;
    scanf("%d", &n);
    int t;
    for(int i = 1; i <= n; i ++)
    {
        scanf("%d", &t);
        s[i] = s[i - 1] + t;
    }
    LL maxc = 0;
    for(int i = 1; i <= n; i ++)
    {
        for(int j = n; j > i ; j --)
        {
            if(maxc > j - i + 1) break;
            //👆降低一点时间复杂度的操作
            LL temp = s[j] - s[i - 1];
            if(temp % 7 == 0)
            {
                maxc = max(maxc, (LL)j - i + 1);
            }
        }
    }
    printf("%lld", maxc);
    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

#include<iostream>
#include<cstdio>
using namespace std;
const int mod=100003;
int n,k,a[1000000],ans=0;
int main()
{
	cin>>n>>k;
	a[0]=a[1]=1;
	for(int i=2;i<=n;++i)
	{
		if(i<=k)
		{
			a[i]=(a[i-1]*2)%mod;
		}
		else 
		{
			a[i]=(a[i-1]*2-a[i-k-1])%mod;
		}
	}
	ans=(a[n]+mod)%mod;
    cout<<ans;
    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
69
70
71
72
73
74
75
76
77
78

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 200010;

LL n,m,s;
LL w[N];
LL v[N];
LL ql[N],qr[N];
LL s_w[N];
LL s_v[N];
LL Y;
LL sum;
LL ans = 0x3f3f3f3f3f3f3f3f;
bool check(LL mid)
{
    Y = 0,sum = 0;
    memset(s_w, 0, sizeof s_w);
    memset(s_v, 0, sizeof s_v);
    //对于Y的计算，我们可以采用前缀和的方式
    for(int i = 1; i <= n; i ++)
    {
        if(w[i] >= mid)
        {
            s_w[i] = s_w[i-1] + 1;
            s_v[i] = s_v[i-1] + v[i];
        }
        else 
        {
            s_w[i] = s_w[i-1];
            s_v[i] = s_v[i-1];
        }
    }
    for(int i = 1; i <= m; i ++)
    {
        Y += (s_w[qr[i]] - s_w[ql[i] - 1]) * (s_v[qr[i]] - s_v[ql[i] - 1]);
    }
    //👆计算Y的值
    //然后开始进行二分
    sum = (LL)abs(Y - s);
    if(Y <= s) return true;
    else return false;
    //能够进行二分的条件判断
    //对于Y;
    //当W为w[N]中最大的那个的时候，Y=0，故应该减小W的值从而增大Y
    //当W为w[N]中最小的那个的时候，Y最大，可能Y>S故应该增大W的值从而减小Y
    //👆以上便是能够进行二分的判断方式
}
int main()
{
    ios::sync_with_stdio(false);
    cin >> n >> m >> s;
    LL wl = 0x3f3f3f3f3f3f3f3f;
    LL wr = 0;
    memset(w, 0, sizeof w);
    memset(v, 0, sizeof v);
    for(int i = 1; i <= n; i ++)
    {
        cin >> w[i] >> v[i];
        wl = min(wl,w[i]);
        wr = max(wr,w[i]);
    }
    for(int i = 1; i <= m ; i ++)
    {
        cin >> ql[i] >> qr[i];
    }
    //?????什么鬼这里改成wl<=wr wr = mid - 1 和 wl = mid + 1才能过
    //二分是真的头疼啊！！我滴妈....
    while(wl <= wr)
    {
        LL mid = wl + wr >> 1;
        if(check(mid)) wr = mid - 1;
        else wl = mid + 1;
        ans = min(ans,sum);
    }
    cout << ans;
    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

#include <bits/stdc++.h>
using namespace std;
const int N = 110;

//i表示编号
//j表示报的号
int main()
{
    int n, m;
    cin >> n >> m;
    bool *out = new bool[N + 1];
    for(int i = 1; i <= n; i ++) *(out + i) = true;
    int i = 1;
    int j = 0;
    int count = 0;
    while(1)
    {
        if(*(out + i))
        {
            j ++;
            if(j == m)
            {
                *(out + i) = false;
                j = 0;
                cout << i << " ";
                count ++;
            }
            if(count == n)//如果所有人都出来了，那就结束
            {
                break;
            }
        }
        i ++;
        if(i > n) //复位一下~
        {
            i = 1;
        }
    }
    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
69
70
71
72
73
74
75
76
77
78
79
80
81

#include <bits/stdc++.h>
#include <queue>
using namespace std;
const int N = 100010;
typedef long long LL;
LL minx[N];
LL a[N];
LL b[N];

int main()
{
    int n;
    priority_queue<int> q;
    scanf("%d", &n);
    for(int i = 1; i <= n; i ++)
    {
        scanf("%lld",&a[i]);
    }
    for(int i = 1; i <= n; i ++)
    {
        scanf("%lld",&b[i]);
    }
    for(int i = 1; i <= n; i ++)
    {
        for(int j = 1; j <= n; j ++)
        {
            int x = a[i] + b[j];
            if(q.size() < n)
            {
                q.push(x);
            }
            else
            {
                if(q.top() > x)
                {
                    q.pop();
                    q.push(x);
                }
                else break;
            }
        }
    }
    for(int i = n; i >= 1; i--)
    {
        minx[i] = q.top();
        q.pop();
    }
    /*
    //TODO:分析一下我到底哪里错了
    minx[1] = a[1] + b[1];
    int j = 2;
    int pos = 2;
    for(int i = 2; i <= n; i ++)
    {
        LL res = a[i-1] +b[j];
        if(a[i] + b[j - 1] < res)
        {
            minx[pos++] = a[i] + b[j - 1];
            continue;
        }
        else
        {
            minx[pos++] = res;
            int k = j;
            k ++;
            res = a[i-1]+b[k];
            while(a[i] + b[j - 1] >= res && k <= n)
            {
                minx[pos++] = res;
                res = a[i-1]+b[k];
                k++;
            }
        }
    }
    */
    for(int i = 1; i <= n; i ++)
    {
        printf("%lld ", minx[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
 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

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

string str;
stack<int> op;
stack<bool> num;
bool t,t1,t2;

//这类题之前先想想，运算符的次序
//同时也要想想运算符的性质
//比如这里not是一元运算符，故需要特判一下
//凡是不满足的时候，都要注意返回ERROR错误值
//exit(0)可以在某个地方直接停止程序
//while(cin >> str)也是一种很好的通过字符串的空格分隔字符的功能 <---发现C++内在的奥妙很重要！
void calc() 
{
	if(op.empty()) return;
	if(op.top()==3) //处理not的计算
    {
		if(num.size()<1)  //一元运算符，只需要看数栈里面是否有1个
        {
			printf("error\n");
			exit(0);
		}
		t=num.top();
		num.pop();
		t=!t;
		num.push(t);
	}
    else if(op.top()==2) //处理and的计算
    {
		if(num.size()<2) 
        { //二元运算符，需要看数栈里面是否有两个
			printf("error\n");
			exit(0);
		}
		t2=num.top();
		num.pop();
		t1=num.top();
		num.pop();
		t=(t1 && t2);
		num.push(t);
	}
    else if(op.top()==1)
    {
		if(num.size()<2) 
        {
			printf("error\n");
			exit(0);
		}
		t2=num.top();
		num.pop();
		t1=num.top();
		num.pop();
		t=(t1 || t2);
		num.push(t);
	}
	op.pop();//计算完毕后，记得运算符栈要出一次
}

int main() 
{
    //优先性 not > and > or
    //        3     2    1
    //发现优先性高的，那就进行出栈运算，计算完后再将新的运算符入栈
	while(cin>>str) //这种输入方式可以被空格隔断，故此可以提取出每个单独的内容
    {
		if(str=="not") op.push(3);
		else if(str=="and") 
        {
			if(num.empty())
            {
				printf("error\n");
				return 0;
			}
			while(!op.empty() && op.top() >= 2) calc();
			op.push(2);
		}
        else if(str=="or") 
        {
			if(num.empty())
            {
				printf("error\n");
				return 0;
			}
			while(!op.empty()) calc();
			op.push(1);
		}
        else if(str=="true") num.push(true);
		else if(str=="false") num.push(false);
	}
    //计算的时候是，每次存入运算符栈的时候，进行判断，如果运算符的优先性更大的话，则进行一次计算
    //最后再看运算符栈，如果运算符栈还没空的话，则继续计算，直到运算符栈空了
	while(!op.empty()) calc(); //如果运算符栈还没空的话，则继续进行计算
	if(num.size()==1)
    {
		if(num.top()) printf("true\n");
		else printf("false\n");
    }
	else printf("error\n");
	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
69
70
71
72
73
74
75

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 1e5+100;
const int M = 1e7+100;
//设置两个队列
//用两个队列来模拟优先队列操作
//一个队列放数组中的数，另外一个放之和的数
//每次操作比较两个队列中对头元素的大小
//桶排序+两个队列来模拟优先队列
queue<LL> q1,q2;
LL a[N];
LL readnum[M];
LL n;
//!这么大的数据一定要开long long
//因为数据量实在是太大了 10^7   10e7的巨大数据量
//所以使用快读函数进行数据的读取
inline int read(){
    int x=0,f=1;
    char ch=getchar();
    while(ch<'0'||ch>'9'){
        if(ch=='-')
            f=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9'){
        x=(x<<1)+(x<<3)+(ch^48);
        ch=getchar();
    }
    return x*f;
}

//作为内联函数访问更快
inline LL getnum()
{
    if(q2.empty() || (q1.front() < q2.front() && !q1.empty()))
    {
        LL x = q1.front();
        q1.pop();
        return x;
    }
    else
    {
        LL x = q2.front();
        q2.pop();
        return x;
    }
}

int main()
{
    n = read();
    LL ans = 0ll;
    memset(a, 0, sizeof a);
    for(int i = 1; i <= n; i ++)
    {
        a[readnum[i] = read()]++;
    }
    for(int i = 1; i <= 100000; i ++)
    {
        for(int j = 1; j <= a[i]; j ++)
        {
            q1.push(i);
        }
    }
    for(LL i = 1; i < n; i ++)
    {
        LL x = getnum();
        LL y = getnum();
        ans += (x+y);
        q2.push(x+y);
    }
    printf("%lld",ans);
    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
69
70
71
72
73
74
75
76
77
78
79
80
81

#include <bits/stdc++.h>
using namespace std;
const int N = 1000;
bool line[N],col[N];
bool lefteg[N],righteg[N];
int path[N];
int n;
int flag = 1;
int counts = 0;
//!搜索最重要的一步就是要想清楚顺序！！
void dfs(int u) //u表示第几层
{
    if(u == n)
    {
        if(flag == 1)
        {
            for(int i = 0; i < n; i ++)
            {
                cout << path[i] << " ";
            }
            if(counts == 2) flag = 0;
            cout << endl;
        }
        counts ++;
        return;
    }
    for(int i = 0; i < n; i ++)
    {
        if(!line[i] && !lefteg[u + i] && !righteg[n - u + i])
        {
            path[u] = i + 1;
            line[i] = lefteg[u + i] = righteg[n - u + i] = 1;
            dfs(u + 1);
            //恢复现场
            line[i] = lefteg[u + i] = righteg[n - u + i] = 0;
        }
    }
}

void dfs2(int x, int y, int s)
//更原始的搜索方式，从左上角开始进行搜索，s表示当前有多少个皇后
{
    if(y == n) y = 0, x ++;
    //表示到达最后一列了，现在返回到第一个位置

    if(x == n)//已经到达最后一行了
    {
        if(s == n) //当前皇后都摆完了
        {
            for(int i = 0; i < n; i ++ ) cout << path[i] << " ";
            counts ++;
            cout << endl;
        }
        return;
    }

    //如果这里不放皇后的话
    dfs2(x, y+1,s);//到下一个位置去放

    //如果放的话
    if(!line[x] && !col[y] && !lefteg[x + y] && !righteg[x - y + n])
    {
        path[x] = y + 1;
        line[x] = col[y] = lefteg[x + y] = righteg[x - y + n] = 1;
        dfs2(x, y + 1, s + 1);
        line[x] = col[y] = lefteg[x + y] = righteg[x - y + n] = 0;
    }
}

int main()
{
    memset(line, 0, sizeof line);
    memset(col, 0, sizeof col);
    memset(lefteg, 0, sizeof lefteg); //左对角线
    memset(righteg, 0, sizeof righteg); //右对角线
    cin >> n;
    dfs(0); //方法一
    dfs2(0,0,0); //更原始的方法
    cout << counts << endl;
    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
69
70
71
72
73
74
75

#include <bits/stdc++.h>
#include <queue>
using namespace std;
const int N = 500;
int n, m, x, y;
int st[N][N];
bool vis[N][N];
typedef pair<int, int> PII;
PII q[N*N];
int dx[9]={0,2,-2,2,-2,-1,1,-1,1};
int dy[9]={0,1,1,-1,-1,2,2,-2,-2};

/*
广度优先搜索dfs会有TLE，可以换采用宽度bfs
回溯、剪枝
int dfs(int x, int y, int s)
{
    st[x][y] = s;
    int nx,ny;
    for(int i = 1; i <= 8; i ++) //八个方向都走一走
    {
        nx = x + dx[i];
        ny = y + dy[i];
        //枚举下一个位置
        //检查一下下一个位置是否合法
        if((nx >= 1 && nx <= n && ny >= 1 && ny <= m)&& (s + 1 < st[nx][ny] || st[nx][ny] == -1))
        {
            //cout << "current position: " << nx << " " << ny <<endl;
            dfs(nx, ny, s + 1);
        }
    }
}
*/

void bfs(int x, int y, int s)
{
    st[x][y] = 0;
    int hh = 0, tt = 0;
    q[0] = {x,y};
    vis[x][y] = true;
    while(hh <= tt)
    {
        auto t = q[hh++];
        for(int i = 1; i <= 8; i ++)
        {
            int nx = t.first + dx[i];
            int ny = t.second + dy[i];
            if((nx > 0 && nx <= n && ny > 0 && ny <= m) && !vis[nx][ny])
            {
                st[nx][ny] = st[t.first][t.second] + 1;//为上一个位置多一个
                q[++ tt] = {nx,ny};
                vis[nx][ny] = true;
            }
        }
    }
}

int main()
{
    ios::sync_with_stdio(false);
    cin >>n >> m >> x >> y;
    memset(st, -1, sizeof st);
    memset(vis, false, sizeof vis);
    //dfs(x,y,0);
    bfs(x,y,0);
    for(int i = 1; i <= n; i ++)
    {
        for(int j = 1; j <= m; j ++)
        {
            cout << left << setw(4) << st[i][j] << " ";
        }
        cout << endl;
    }
    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

#include  <bits/stdc++.h>
using namespace std;
const int N = 2000;
int q[N];
int l[N];
int da[3] = {0,1,-1};
bool vis[N];
int n,a,b;

//最少按键次数，最小问题——>bfs
void bfs(int sa)
{
    int hh = 0, tt = 0;
    q[0] = sa; // 入队
    vis[sa] = true;
    int dis[N];
    int flag = 0;
    memset(dis, 0, sizeof dis);
    dis[0] = 0; //从sa开始到达每个点的距离
    while(hh <= tt)
    {
        int t = q[hh ++];
        if (t == b)
        {
            flag = 1;
            break;
        }
        for(int i = 1; i <= 2; i ++)
        {
            int na = t + da[i]*l[t];
            if(na > 0 && na <= n && vis[na] == false)
            {
                dis[na] = dis[t] + 1;
                q[++ tt] = na;
                vis[na] = true;
            }
        }
    }
    if(flag == 1) cout << dis[b];
    else cout << -1;
    return;
}
int main()
{
    ios::sync_with_stdio(false);
    cin >> n >> a >> b;
    memset(vis, false, sizeof vis);
    for(int i = 1; i <= n; i ++) cin >> l[i];
    bfs(a);
    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
69
70
71
72
73
74
75
76
77
78
79
80

#include <bits/stdc++.h>
using namespace std;
const int N = 110;
typedef pair<int,int> PII;
int g[N][N];
int n,m,x;
int stx,sty,enx,eny;
int dx[5] = {0, -1, 0, 1, 0};
int dy[5] = {0, 0, 1, 0, -1};
PII q[N*N];
int d[N][N];
int counts = 0;

//宽度优先搜索
void dfs(int xx, int yy)
{
    if(xx == enx && yy == eny)
    {
        counts++;
        return;
    }
    else
    {
        for(int i = 1; i <= 4; i ++)
        {
            int nx = xx + dx[i];
            int ny = yy + dy[i];
            if(nx > 0 && nx <= n && ny > 0 && ny <= m && g[nx][ny] == 0 && d[nx][ny] == -1)
            {
                d[xx][yy] = 1;
                dfs(xx+dx[i],yy+dy[i]);
                d[xx][yy] = -1;
            }
        }
    }
}
int bfs()
{
    int hh = 0, tt = 0;
    q[0] = {stx, sty};
    memset(d, -1, sizeof(d));
    d[1][1] = 1;
    while(hh <= tt)
    {
        auto t = q[hh++];
        for(int i = 1; i <= 4; i ++)
        {
            int x = t.first + dx[i];
            int y = t.second + dy[i];
            if(x > 0 && x <= n && y > 0 && y <= m && g[x][y] == 0 && d[x][y] == -1)
            {
                d[x][y] = 1;
                if(x == enx && y == eny)
                {
                    counts++;
                }
                q[++ tt] = {x,y};
            }
        }
    }
    return counts;
}
int main()
{
    ios::sync_with_stdio(false);
    cin >> n >> m >> x;
    cin >> stx >> sty >> enx >> eny;
    memset(g, 0, sizeof 0);
    memset(d, -1, sizeof(d));
    for(int i = 1; i <= x; i ++)
    {
        int t,p;
        cin >> t >> p;
        g[t][p] = 1;
    }
    //cout << bfs();
    dfs(stx, sty);
    cout << counts;
    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

#include <bits/stdc++.h>
#include <unordered_map>
#include <cstring>
#include <queue>

using namespace std;
unordered_map<string,int> dist;
queue<string> q;

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

int bfs(string str)
{
    string z = "123804765";
    q.push(str);
    dist[str] = 0;
    while(!q.empty())
    {
        auto t = q.front();
        q.pop();
        int dis = dist[t];
        if(t == z) return dis; //如果已经满足条件则返回步数

        int po = t.find('0');//在字符串中寻找空位所在的位置
        //将一维度转化为三维
        int x = po / 3;
        int y = po % 3;

        for(int i = 1; i <= 4; i ++)
        {
            int nx = x + dx[i];
            int ny = y + dy[i];
            if(nx >= 0 && nx < 3 && ny >= 0 && ny < 3)
            {
                swap(t[po], t[nx*3+ny]);  //<---这里又有将三维情况转化成一维

                if(!dist.count(t)) //map操作，如果t没有出现过的话
                {
                    dist[t] = dis + 1;
                    q.push(t);
                }
                swap(t[po], t[nx*3+ny]);
            }
        }
    }
    return -1;
}
int main()
{
    string p_str;
    cin >> p_str;
    cout << bfs(p_str);
    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

#include <bits/stdc++.h>
#include <cstring>

using namespace std;
const int N = 110;
char g[N][N];
bool st[N][N];
int n,m;
int dx[9] = {0,1,1,1,0,0,-1,-1,-1};
int dy[9] = {0,0,1,-1,1,-1,0,1,-1};
void dfs(int x, int y)
{
    st[x][y] = true;
    if(x <= 0 || x > n || y <= 0 || y > m) return;
    for(int i = 1; i <= 8; i ++)
    {
        int nx = x + dx[i];
        int ny = y + dy[i];
        if(g[nx][ny] == '@' && !st[nx][ny])
        {
            dfs(nx,ny);
        }
    }
}
int main()
{
    while(cin >> n >> m)
    {
        memset(st, false, sizeof st);
        int counts = 0;
        if(n == 0|| m == 0) return 0;
        for(int i = 1; i <= n; i ++)
        {
            for(int j = 1; j <= m; j ++)
            {
                cin >> g[i][j];
            }
        }
        for(int i = 1; i <= n; i ++)
        {
            for(int j = 1; j <= m; j ++)
            {
                if(g[i][j] == '@' && !st[i][j])
                {
                    counts++;
                    dfs(i,j);
                }
            }
        }
        cout << counts << endl;
    }
    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

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 1010;
bool st[N];
LL a[N];
LL sa[N];
LL ans;
int n,s;

void dfs(int u, LL sum)
{
    ans = max(ans,sum);
    if(u == 0) return; //退出条件-->到达边界
    //👇进行剪枝
    if(sa[u] + sum <= s)//继续枚举下去，肯定都是会比这个sa[u]+sum小的，故直接剪枝优化算法
    {
        ans = max(ans, sa[u] + sum);
        return;
    }//如果u前缀和的项目+sum <= 标准值的话，则更新一下ans，也就是u之前的砝码都可以取用了
    if(a[u] + sum <= s)
    {
        dfs(u - 1, sum + a[u]);
    }//如果当前这个位置的值a[u] + sum <= s的话，取一下当前位置  <---也像一个剪枝
    dfs(u - 1, sum); //都不满足的话，那就继续递归下一个
}

int main()
{
    cin >> n >> s;
    for(int i = 1 ; i <= n; i ++) cin >> a[i];
    for(int i = 1 ; i <= n; i ++) sa[i] = sa[i - 1] + a[i];
    dfs(n,0);
    cout << ans;
    return 0;
}