？？？？？？？？

原创于 2024-10-27 20:59:57 发布 · 822 阅读

本内容遵循CC 4.0 BY-SA版权协议

考虑一个棋子的过程， xoxxx要三步结束xoooxxx的话如果一个一个走要12步，如果走一个操作2就是xxoooxx，这个走一个一个走要9步，加上刚刚的就是10步，发现走完的奇偶性不变，直接判断操作的奇偶就可以了

void solve()
{
  int n;
  string s;
  cin >> n >> s;
  int sum = 0;
  s = " " + s;
  for (int i = 1; i <= n; i++)
  {
    if (s[i] == 'o')
      sum += n - i;
  }
  if (sum % 2 == 0)
    cout << "L" << endl;
  else
    cout << "M" << endl;
}

模拟过程，记得开long long 去重

#define int long long
const int N = 2e5 + 10;
int A[N], B[N], n;
bool check(int x)
{
    if (x < 2)
        return false;
    for (int i = 2; i * i <= x; i++)
    {
        if (x % i == 0)
            return false;
    }
    return true;
}
void solve()
{
    cin >> n;
    int len = 0;
    for (int i = 1; i <= n; i++)
        cin >> A[i];
    for (int i = 1; i <= n; i++)
    {
        int num = A[i];
        if (check(num))
            B[len++] = num;
        for (int j = i + 1; j <= n; j++)
        {
            if (A[j] < 10)
            {
                num *= 10;
                num += A[j];
            }
            else
            {
                num *= 100;
                num += A[j];
            }
            if (check(num))
                B[len++] = num;
        }
    }
    sort(B, B + len);
    int len_ = unique(B, B + len) - B;
    if (len_)
    {
        cout << len_ << endl;
        for (int i = 0; i < len_; i++)
        {
            if (i)
                cout << " ";
            cout << B[i];
        }
    }
    else
    {
        cout << "None";
    }
}

百度二维前缀和算法

经典BFS算法，走的方向变成12个了，记得用字符串判断能不能走，不能走到答案上，而是周围

也是BFS的改编

对于箱子BFS，然后对人BFS找一下能不能走到箱子的周围来推箱子

经典DFS

#define int long long
const int N = 2e5 + 10;
int n;
int W[N];
void dfs(int a, int b, int p)
{
    if (a == 0)
    {
        if (p == 1)
            return;
        cout << n << "=";
        for (int i = 0; i < p; i++)
        {
            if (i)
                cout << "+";
            cout << W[i];
        }
        cout << endl;
        return;
    }
    for (int i = b; i <= n; i++)
    {
        if (i <= a)
        {
            W[p] = i;
            dfs(a - i, i, p + 1);
        }
    }
}
void solve()
{
    while (cin >> n)
    {
        dfs(n, 1, 0);
    }
}

题目意思就是从a送到b，送一次10分钟，问最久，我们就只考虑路程中冲突最多的位置*10就可以，这个英文反而比较简单

#include <bits/stdc++.h>
using namespace std;
int a, b, A[1010], B[1010];
// B是存的每一套导弹系统当前打的最低的
int main()
{
    while (scanf("%d", &a) != EOF)
    {
        for (int i = 0; i < a; i++)
        {
            cin >> A[i];
        }
        int op = 0;
        for (int i = 0; i < a; i++)
        {
            int k = 0;
            for (int j = 0; j < op; j++)
            {
                if (B[j] >= A[i])
                {
                    B[j] = A[i];
                    k++;
                    break;
                }
            }
            if (k == 0)
            {
                B[op] = A[i];
                op++;
            }
        }
        printf("%d\n", op);
    }
    return 0;
}

贪心，我们对于当前最慢的两个人要么就是用最快的内个人一个一个送过去（回来要时间，最快用的少），要么就是1和2先过去，然后1回来，然后让这俩个人一起过去，然后2回来

因为最慢的要过去，要么就是他顺便把倒数第二慢的过去=，要么就是被1送过去

#include <iostream>
#include <algorithm>
using namespace std;
int n, b, A[100001];
int main()
{
    int op = 0;
    while (scanf("%d", &n) != EOF)
    {
        for (int i = 1; i <= n; i++)
            scanf("%d", &A[i]);
        sort(A + 1, A + n + 1);
        int ans = 0;
        while (n >= 4)
        {
            ans = ans + min(A[1] + A[2] + A[2] + A[n], A[n] + A[n - 1] + A[1] + A[1]);
            n = n - 2;
        }
        if (n == 1)
            printf("%d\n", A[1] + ans);
        if (n == 2)
            printf("%d\n", A[2] + ans);
        if (n == 3)
            printf("%d\n", A[3] + A[2] + A[1] + ans);
    }
    return 0;
}

百度01背包

也是BFS，先把可以扩展的入队，然后把一个方块染色后就判断一下他的周围的方块能不能染色，入队

或者循环？次，刚好不超时也能过

二分答案

这个信息学奥赛一本通（1246：膨胀的木棍）_信奥一本通 1246-CSDN博客

标签