NEUQ-ACM2022预备队 2023春 第三周

最新推荐文章于 2024-08-08 15:12:59 发布
最新推荐文章于 2024-08-08 15:12:59 发布
阅读量134 收藏
点赞数
文章标签： 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhousinan04/article/details/129913433
版权

第三周训练

训练主要内容：模拟、搜索

第一题 饿饿 饭饭2

题目链接

题目1

给孩子 n n n 个数字。孩子可以选择任意一个乘以 2 2 2 或 3 3 3 。问孩子是否能把所有数变成同一个数。

思路1

先求所有数的最大公约数。然后逐个将每一个数字除以最大公约数，得到一个新数，如果这个新数是由 2 2 2 和 3 3 3 相乘得到的，那么这个数可以由最大公约数乘了多个 2 2 2 或 3 3 3 得到。
如果所有数都能由最大公约数乘了多个 2 2 2 或 3 3 3 得到，那么这些数都差多个 2 2 2 或 3 3 3，可以通过乘 2 2 2 或 3 3 3 得到相同的数。

代码1

#include<iostream>
#include<algorithm>
using namespace std;

constexpr int maxn = 2e5 + 5;
int t, n;
//存放数字
int nums[maxn];

int main()
{
    cin >> t;
    while (t--)
    {
        cin >> n;
        //最大公约数
        int m = -0x3f3f3f3f;
        for (int i = 1; i <= n; i++)
        {
            cin >> nums[i];
            //只有一个数时就时本身
            if (i == 1)
            {
                m = nums[i];
            }
            else
            {
                m = __gcd(m, nums[i]);
            }
        }
        //ans标记是否符合题意
        bool ans = true;
        for (int i = 1; i <= n; i++)
        {
            //本身就是最大公约数就不需要判断了
            if (m == nums[i])
            {
                continue;
            }
            //新数
            int temp = nums[i] / m;
            //拆分新数
            while (temp > 1)
            {
                if (temp % 3 == 0)
                {
                    temp /= 3;
                }
                else if (temp % 2 == 0)
                {
                    temp /= 2;
                }
                //不能拆成2和3的组合，那这个数就不符合要求，就不能得到相同的数
                else
                {
                    ans = false;
                    break;
                }
            }
            //不符合题意提前跳出
            if (!ans)
            {
                break;
            }
        }
        cout << (ans ? "YES" : "NO") << endl;
    }
    return 0;
}

第二题 子串分值和

题目链接

题目2

定义 f ( S ) f(S) f(S) 为 S S S 中出现的不同的字符个数。
给定一个字符串 S S S ，长度为 l e n len len ，计算 ∑ i = 0 l e n − 1 ∑ j = i l e n − 1 f ( S [ i : j ] ) \sum_{i = 0}^{len - 1} \sum_{j = i}^{len - 1} f(S[i : j]) ∑i=0len−1​∑j=ilen−1​f(S[i:j]) 。

思路2

可以按字符分开计算，最后再累加。
要找出所有含有某字符的子串比较麻烦。但是要找到不含有某字符的子串很方便，只需要找到所有不含某字符的区间，根据区间长度即可很方便地计算出不含某字符的所有子串数。子串的总数量也很好计算，所以就可以方便地计算出含有某字符的子串的数量。
按字符分别计算出含有该字符的子串数量，再进行相加就可以得到答案。

代码2

#include<iostream>
#define int long long
using namespace std;

//字符串长度，答案，所有子串的数量
int len, ans, total;

signed main()
{
    string s;
    cin >> s;
    len = (int)s.size();
    //尾部加上任意一个字符，方便后面的处理
    s.push_back(' ');
    //计算所有子串的数量
    total = len * (len + 1) / 2;
    //遍历所有字符
    for (char c = 'a'; c <= 'z'; c++)
    {
        int cnt = 0;
        int temp = 0;
        //遍历字符串
        for (int i = 0; i <= len; i++)
        {
            //找到不含该字符的区间
            if (s[i] != c && s[i] != ' ')
            {
                temp++;
            }
            //区间结束后，计算该区间中所有不含该字符的子串数量
            else
            {
                //公式为len * (len + 1) / 2
                cnt += temp * (temp + 1) / 2;
                temp = 0;
            }
        }
        //所有子串数减不含该字符的子串数得到含该字符的子串数。进行累加。
        ans += total - cnt;
    }
    cout << ans << endl;
    return 0;
}

第三题 蒟蒻

题目链接

题目3

有一排果冻，每个果冻都有价格和口感。鶸尛鱻挑选果冻，有三种操作：

  1. 把一个价格为 w w w ，口感为 t t t 的果冻放入篮子。
  2. 拿出篮子中最为廉价的果冻。
  3. 拿出篮子中口感最差的果冻。

此外他不会选择价格或口感相同的果冻。
经过一定的操作，问篮子里果冻的总价格。

思路3

这道题要同时按两个方式进行排序，并且还需要不断的添加和删除，所以可以选择一个自动排序的容器来存放这些果冻。
每个果冻有两个属性，且不会重复，很适合使用 m a p map map 来存储。可以使用两个 m a p map map ，一个键为价格值为口感，一个键为口感值为价格，就可以同时按两个方式排序并且能通过任意一个属性去找果冻。

代码3

#include<iostream>
#include<map>
using namespace std;

int main()
{
    //两个map
    map<int, int> wt, tw;
    int n;
    cin >> n;
    while (n--)
    {
        int op;
        cin >> op;
        switch(op)
        {
            //添加
            case 1:
                int w, t;
                cin >> w >> t;
                //保证没有口感或价格相同的果冻
                if (wt.count(w) == 0  && tw.count(t) == 0)
                {
                    wt[w] = t;
                    tw[t] = w;
                }
                break;
            case 2:
                //价格最低的果冻时wt.begin()，wt.begin()->second就是它的口感
                tw.erase(wt.begin()->second);
                wt.erase(wt.begin());
                break;
            case 3:
                //口感最低的果冻时tw.begin()，tw.begin()->second就是它的价格
                wt.erase(tw.begin()->second);
                tw.erase(tw.begin());
                break;
            default:
                break;
        }
    }
    int ans = 0;
    //遍历计算价格
    for (pair<int, int> p : wt)
    {
        ans += p.first;
    }
    cout << ans << endl;
    return 0;
}

第四题 锦标赛

题目链接

题目4

有 n n n 个玩家参加比赛，他们分别有一个能力值 a i a_i ai​。
进行 n − 1 n - 1 n−1 场比赛，选两个玩家 i i i 和 j j j 。若 ∣ a i − a j ∣ > K | a_i - a_j | > K ∣ai​−aj​∣>K，那么高能力值的获胜，否则都可能获胜。
问最后可能获胜的玩家有多少个。

思路4

把所有人的能力值排序。能力值最高的如果比第二高的大 K K K，那么第二高的就不能获胜，剩下的也就不能获胜，所以这个情况下只有能力值最高的能赢。如果第二高的能获胜，通过同样的方法也可以判断剩下的人能否获胜。
所以只需要从能力值最高的开始遍历，如果相邻两人能力值差大于 K K K ，那后面的人就不能获胜，能获胜的人是能力值高的人和在他前面的人。

代码4

#include<iostream>
#include<algorithm>
using namespace std;

constexpr int maxn = 100001;
//ans是答案，最少有一个人获胜
int n, k, ans = 1;
int a[maxn];

int main()
{
    cin >> n >> k;
    if (n == 0)
    {
        cout << 0 << endl;
        return 0;
    }
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
    }
    //从大到小排序
    sort(a + 1, a + n + 1, [](int a, int b) { return a > b; });
    //逐个遍历
    for (int  i = 1; i < n; i++)
    {
        //差小于等于k，两个人都有可能赢，剩下的人也就有可能赢
        if (a[i] - a[i + 1] <= k)
        {
            ans++;
        }
        //差大于k，只有一个人能赢，剩下的人也没有机会赢，所以中止遍历
        else
        {
            break;
        }
    }
    cout << ans << endl;
    return 0;
}

第五题 可重排列

题目链接

题目5

按字典序从小到大的顺序输出所有序列，满足序列中有 p 1 p_1 p1​ 个 1 1 1， p 2 p_2 p2​ 个 2 2 2， … \ldots …， p n p_n pn​ 个 n n n 。

思路5

使用dfs去遍历。

代码5

#include<cstdio>
#include<vector>
using namespace std;

int n, cnt = 0;
//存放每个数字的个数
int nums[15];

void dfs(vector<int>& v)
{
    //已经全选完看
    if (v.size() == cnt)
    {
        //逐个输出
        for (int i = 0; i < cnt; i++)
        {
            printf("%d ", v[i]);
        }
        printf("\n");
        return;
    }
    for (int i = 1; i <= n; i++)
    {
        //如果该数字还有
        if (nums[i] > 0)
        {
            //使用一个
            nums[i]--;
            //放到序列后面
            v.push_back(i);
            //下一轮搜索
            dfs(v);
            //复原
            nums[i]++;
            v.pop_back();
        }
    }
}

int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &nums[i]);
        cnt += nums[i];
    }
    vector<int> v;
    //从不同数字开始搜索
    for (int i = 1; i <= n; i++)
    {
        v.push_back(i);
        nums[i]--;
        dfs(v);
        nums[i]++;
        v.pop_back();
    }

    return 0;
}

第六题 进制转换

题目链接

题目6

以不同进制的形式输入 n n n 个非负整数，求出它们的和并以 m m m 进制的形式输出。
使用大写字母 A A A ~ Z Z Z 依次代表 10 10 10 ~ 35 35 35 ，小写字母 a a a ~ z z z 依次代表 36 36 36 ~ 61 61 61 。

思路6

先全部转换为十进制（因为十进制方便处理），累加完再转换为题给进制。

代码6

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

int n, m, t;
string num;
//ans是十进制的累加结果
long long ans = 0;

//把字符表示的数字转换为数字
int getNum(char c)
{
    if (c >= '0' && c <= '9')
    {
        return c - '0';
    }
    else if (c >= 'A' && c <= 'Z')
    {
        return c - 'A' + 10;
    }
    else if (c >= 'a' && c <= 'z')
    {
        return c - 'a' + 36;
    }
    else
    {
        return 0;
    }
}

//将数字转换为字母表示的数字
char getChar(int n)
{
    if (n >= 0 && n <= 9)
    {
        return n + '0';
    }
    else if (n >= 10 && n <= 35)
    {
        return n - 10 + 'A';
    }
    else if (n >= 36 && n <= 61)
    {
        return n - 36 + 'a';
    }
    else
    {
        return 0;
    }
}

int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
    {
        //temp存放进制转换结果
        long long temp = 0;
        cin >> t >> num;
        //转换
        for (int i = 0; i < (int)num.size(); i++)
        {
            temp *= t;
            temp += getNum(num[i]);
        }
        ans += temp;
    }
    //将ans进行进制转换
    //s存放进制转换的结果
    char s[1000];
    memset(s, 0, sizeof(s));
    //temp存放索引
    int temp = 0;
    //进制转换
    while (ans > 0)
    {
        s[temp++] = getChar(ans % m);
        ans /= m;
    }
    //放的时候反向，需要反转
    reverse(s, s + temp);
    cout << s << endl;

    return 0;
}

第七题 循环子串

题目链接

题目7

一个字符串 S S S 是另一字符串 T T T 的循环子串当且仅当存在 k k k， T T T 所有字符循环右移 k k k 位后得到的新串 T ′ T^′ T′，满足 S S S 是 T ′ T^′ T′ 的子串。
一个串 P P P 是完全循环串当且仅当对于它的任一子串 H H H
，都有 H r e v e r s e H_{reverse} Hreverse​ 是 P P P 的循环子串（ H r e v e r s e H_{reverse} Hreverse​ 为 H H H 的倒转）。
给一个长度为 n n n 的字符串，判断它是不是完全循环串。

思路7

如果一个子串是 P P P 的循环子串，很容易看出这个子串的所有子串也是 P P P 的循环子串。所以只需要判断 P P P 本身是否为 P P P 的循环子串即可。

代码7

#include<iostream>
#include<algorithm>
using namespace std;
//用于循环子串的判断，读取这个字符串的内容时会无限循环
class circleString
{
private:
    //原字符串
    string s;
    //长度
    size_t length;
    //当前读取的位置
    size_t now;
public:
    //构造函数
    circleString(const string& str) : s(str), length(str.size()), now(0) { }
    //设置当前的位置
    void setNow(int n)
    {
        now = n;
    }
    //读取下一个字符
    char nextChar()
    {
        now++;
        if (now >= length)
        {
            now = 0;
        }
        return s[now];
    }
    //获取当前的字符
    char nowChar()
    {
        return s[now];
    }
};

int t, n;
string s;

int main()
{
    cin >> t;
    while (t--)
    {
        bool ans = false;
        cin >> n >> s;
        circleString cs(s);
        //将s反转得到Hreverse
        reverse(s.begin(), s.end());
        //寻找每一个起点
        for (int i = 0; i < (int)s.size(); i++)
        {
            //设置起点
            cs.setNow(i);
            //如果有第一个字符相同，就继续判断后面的字符是否相同
            if (cs.nowChar() == s[0])
            {
                //标记是否完全相同
                bool same = true;
                //遍历字符串
                for (int j = 1; j < (int)s.size(); j++)
                {
                    if (cs.nextChar() != s[j])
                    {
                        same = false;
                        break;
                    }
                }
                if (same)
                {
                    ans = true;
                    break;
                }
            }
        }
        cout << (ans ? "YES" : "NO") << endl;
    }
    return 0;
}

第八题 饿饿 饭饭之暑假大狂欢

题目链接

题目8

有 t t t 个玩家，每个玩家都有一张带有数字的卡片。第 i i i 张卡片上有 n i n_i ni​ 个数字。主持人从袋子里取出编号的球， 如果玩家的卡片上有对应的数字，就可以将它划掉。 最先从他的卡片上划掉所有数字的人获胜。如果多人同时从他们的卡片上划掉所有数字，那么这些人都不能赢得比赛。
问每个玩家是否可以在最有利于他的情况下赢得比赛。

思路8

如果一个玩家的数字完全包含了另一个玩家的数字，那么另一个玩家会比这个玩家早或者和这个玩家同时划完数字，这个玩家必不可能赢。
但如果一个玩家的数字不完全包含任何一个玩家的数字，那情况最好时别人最后总会剩下一张他没有的数字，他能获胜。
所以需要判断每个玩家的数字是否完全包含别的玩家的数字。

代码8

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

int t;
//多个vector存放每个人的数字
vector<int> v[101];

int main()
{
    cin >> t;
    //输入
    for (int i = 1; i <= t; i++)
    {
        int n, temp;
        cin >> n;
        while (n--)
        {
            cin >> temp;
            v[i].push_back(temp);
        }
    }
    for (int i = 1; i <= t; i++)
    {
        //ans标记这个玩家是否获胜
        bool ans = true;
        //遍历其他玩家
        for (int j = 1; j <= t; j++)
        {
            //跳过都是自己的情况
            if (i == j)
            {
                continue;
            }
            //完全包含的前提是数字不能比另一个人少
            if (v[i].size() >= v[j].size())
            {
                //表示是否完全包含
                bool sub = true;
                //遍历另一个人的所有数字
                for (int k = 0; k < (int)v[j].size(); k++)
                {
                    //标记这个玩家是否有这个数字
                    bool contain = false;
                    //遍历这个玩家所有的数字
                    for (int x = 0; x < (int)v[i].size(); x++)
                    {
                        //有
                        if (v[j][k] == v[i][x])
                        {
                            contain = true;
                        }
                    }
                    //如果没有，那么就不可能完全包含
                    if (!contain)
                    {
                        sub = false;
                        break;
                    }
                }
                //如果完全包含，他就不可能赢
                if (sub)
                {
                    ans = false;
                    break;
                }
            }
        }
        cout << (ans ? "YES" : "NO")  << endl;
    }
    return 0;
}

第九题 RSA

题目链接

题目9

RSA算法选择两个不同质数的积作为模数。现在有两个正整数 A A A ， B B B ，如果它们是不同的质数，则判定为 full credit；否则，如果 A × B A \times B A×B，不是任意大于 1 1 1 的整数的平方的整数倍，则判定 partial credit；否则判定为no credit。

思路9

这道题要解决两个问题：判断质数和判断是否为平方的整数倍。
判断质数需要找到所有的因数。判断是否为平方的整数倍也可以通过寻找所有的因数，然后去找是否有相同的因数。所以这个题的核心就是寻找因数。

代码9

#include<iostream>
#include<cmath>
#include<map>
using namespace std;
//记录A的因数
map<int, int> ma;
//记录B的因数
map<int, int> mb;
//分解因数
void disintegral(long long n, map<int, int>& m)
{
    //本身也是因数。1不需要算入其中。
    m[n]++;
    //判断2是否为因数
    if (n % 2 == 0)
    {
        m[2]++;
        //判断2的平方是否为因数
        if ((n / 2) % 2 == 0)
        {
            m[2]++;
        }
    }
    //判断其他数
    for (long long i = 3; i <= (int)sqrt(n); i+=2)
    {
        if (n % i == 0)
        {
            m[n / i]++;
            m[i]++;
            //判断i的平方是否为因数
            if ((n / i) % i == 0)
            {
                m[i]++;
            }
        }
    }
}

//判断是否是平方的整数倍
bool isPow()
{
    for (pair<int, int> p : ma)
    {
        //如果A的因数里已经有重复因数了就说明肯定是平方的整数倍
        if (p.second > 1)
        {
            return true;
        }
        else
        {
            //A和B相同因数有多个也说明平方的整数倍
            if (p.second + mb[p.first] > 1)
            {
                return true;
            }
        }
    }
    return false;
}

int main()
{
    long long a, b;
    cin >> a >> b;
    //分解因数
    disintegral(a, ma);
    disintegral(b, mb);
    //不相同而且都是质数
    if (a != b && ma.size() == 1 && mb.size() == 1)
    {
        cout << "full credit" << endl;
    }
    //不是平方的整数倍
    else if (!isPow())
    {
        cout << "partial credit" << endl;
    }
    else
    {
        cout << "no credit" << endl;
    }

    return 0;
}

第十题 数组操作

题目链接

题目10

给你一个有 n n n 个元素的数组 a a a 。你可以对它进行如下操作，次数不限。从一个偶数大小为 2 k 2k 2k 的数组中选择一些从位置 l l l 开始的子数组（ 1 ⩽ l + 2 × k − 1 ⩽ n , k ⩾ 1 1\leqslant l + 2 \times k − 1 \leqslant n, k \geqslant 1 1⩽l+2×k−1⩽n,k⩾1） ，对于 0 0 0 到 k − 1 k − 1 k−1（包括）之间的每一个 i i i ，将值 a l + k + i a_{l + k + i} al+k+i​ 分配给 a l + i a_{l + i} al+i​ 。
请找出使数组中所有元素相等所需的最少操作数（可能是零）。

思路10

题给的操作其实是将数组的一部分复制到这一部分的前面那一部分。
因为只能把后面复制到前面，所以最终数组会全变成最后一个数字。
从最后一个数字开始向前遍历，如果遇到了一个不同的数字，就说明需要复制了。由于复制的大小不受限制，所以最好地效果就是把后面的所有相同数字都复制过去，这样不仅可以把这个数字改成相同数字，还可以把前面可能存在的不同数字也改成相同数字。反复这样操作即可将数组全变成最后一个数字。

代码10

#include<cstdio>

constexpr int maxn = 2e5 + 5;
int a[maxn];

int main()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        int n;
        scanf("%d", &n);
        for (int i = 1; i <= n; i++)
        {
            scanf("%d", &a[i]);
        }
        //要变成的相同数字，操作的次数
        int samenum = a[n], cnt = 0;
        for (int i = n; i > 0; i--)
        {
            //相同就继续向前
            if (a[i] == samenum)
            {
                continue;
            }
            //不相同就需要一次操作
            cnt++;
            //根据思路中所述，2 * i - n之后的数字都会变成相同数字，直接跳过即可
            //由于循环结束还会自减，所以i设置为2 * i - n + 1
            i = 2 * i - n + 1;
        }
        printf("%d\n", cnt);
    }
    return 0;
}
zhousinan04
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Henrik-Yao#NEUQ-ACM-Solution#第三次双周赛1
07-25
7-1 词典map应用，把外语方言设为关键词，一个关键词对应一个英语单词7-2 神秘密码对每一个字符单独处理，注意 '[' ']'和数字的处理方式（伪证7-3
Henrik-Yao#NEUQ-ACM-Solution#题解23
07-25
题解先设置一个字符组，将字符存入，设置一个大循环，对于每一次输入的字符组将其存入，依次和原字符组进行比较，最后统计相同即可。long long ans(long
2020：【例4.5】第几项 信息学奥赛一本通（C++版）
m0_63998667的博客
05-13 301
对于正整数n,mn,m，求s=1+2+3……+ns=1+2+3……+n，当加到第几项时，ss的值会超过mm？对于全部数据：1≤m≤400001≤m≤40000。2020：【例4.5】第几项。
ACM——POJ 3295 （Tautology）
wei121422198的专栏
09-03 871
#include<iostream>#include<cmath>usingnamespace std;int c[5];voidf(int a){int i;for(i=0;i<=5;i++) c[i]=0; i=0;while(a!=0){ c[i]=a%2; a/=2; i++;}}intmain(){int i,j,k,p,l,s[101],t;char a[102],b[10];while(gets(a),a[0]!='0'){ l=strlen(a)
JDK11占比第一？
u011385940的专栏
07-07 4078
根据软件服务公司New Relic 发布的《2022 年 Java 生态系统现状》报告中，Java 11已成为新的标准（占比48.44%）。Java11是一个长期支持版本（Long-term supper version）。共包含17个JEP（JDK Enhancement Proposals，JDK增强提案）。开发一个处理内存分配但不实现任何实际内存回收机制的 GC。一旦可用的 Java 堆用完，JVM 就会关闭。以内存占用和内存吞吐量为代价，提供具有有限分配限制和尽可能低的延迟开销的完全被动 GC 实现
NEUQ-ACM2022预备队 2023春 第二周
zhousinan04的博客
03-26 195
动态规划、模拟、数据结构
NEUQ-ACM2022预备队 2023春 第一周
zhousinan04的博客
03-19 104
动态规划和模拟
NEUQ-ACM2022预备队 2023春 第五周
zhousinan04的博客
04-15 114
找一个能够让他在空旷无树的地方修建牛棚的地方。cc希望将其中的一些物品放入他的背包中，他希望这些物品的体积之和至少是背包体积的一半，并且不超过背包的体积，即。可以先存储所有加上的数的和，在出列的时候再加，入列的时候再减。由于题目要求下标整除，所以可以用前面的下标去推后面所有能整除的下标，这样更加快速。如果最多的糖果要多于其他糖果的和再加一，则不管怎么吃，都会出现连续吃两次的情况。计算并输出，在他的农场中，不需要砍树却能够修建的最大正方形牛棚。是否可以在不连续吃两个相同的糖果的情况下吃掉所有的糖果。
NEUQ-ACM2022预备队 2023春 第四周
zhousinan04的博客
04-09 213
排好队后，所有的大臣都会获得国王奖赏的若千金币，每位大臣获得的金币数分别是：排在该大臣后面的所有人的左手上的数的乘积乘以他自己右手上的数。安排一下队伍的顺序使所有大臣获得的金币数之和最多。如果将后面人左手上的数乘以自己右手的数（对自己获得的钱的影响）加上后面人右手上的数（对后面人获得的钱影响）大，则这个站位有利于得到更多的金币。组成的所有数的和相等。可以先把1之间的0省略，然后将剩下的数进行排列，再在每两个1之间插入。逆元：在余数中，除以一个数等于乘以一个数的逆元。的01序列，请问有多少种不同的构造方法。
NEUQ-ACM2022预备队第三周作业
zhousinan04的博客
11-14 288
线性表
NEUQ-ACM预备队蓝桥杯题解提交处.zip
01-24
全国电子设计大赛、全国大学生智能汽车竞赛、蓝桥杯、集成电路创新创业大赛、光电设计竞赛、挑战杯、大创项目、互联网+、三创赛、计算机设计竞赛、创新创业大赛、ACM-ICPC国际大学生程序设计竞赛、全国大学生数学...
Henrik-Yao#NEUQ-ACM-Solution#题解59
07-25
1.最大子段和 2.汉诺塔问题 3.汉诺塔3 4.汉诺塔2 5.简单的归并 6.字符串的全排列 7. 逆序对 8.二分查找
Henrik-Yao#NEUQ-ACM-Solution#Week 9 题解1
07-25
1.一个1*1的块和a[n-1]组合 2.一个2*1的块和a[n-2]组合 3.一个3*1的块和a[n-3]组合
P1145 约瑟夫
zty20120913的博客
08-06 424
n个人站成一圈，从某个人开始数数，每次数到m的人就被杀掉，然后下一个人重新开始数，直到最后只剩一个人。现在有一圈人，k个好人站在一起，k个坏人站在一起。从第一个好人开始数数。你要确定一个最小的m，使得在第一个好人被杀死前，k个坏人先被杀死。
C++初学者指南-5.标准库(第二部分)--数值运算算法
silencestarsky的博客
08-06 940
本文介绍了C++标准库中数值运算的相关算法，重点包括iota、reduce和各种扫描操作（scans），阐述了这些算法的用途、用法及其实现示例，并对并行执行的支持进行了说明。此外，文章还提到了一些遗留操作及其使用场景，为初学者理解C++标准库提供了实用的参考。
day 9 回溯算法
最新发布
m0_73924943的博客
08-08 248
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
day021二叉树最后章节
m0_62956971的博客
08-06 574
思路: 二叉搜索树的中序遍历就是有序升序数组，所以想要将它在转换成二叉树，我想到的方法就是通过递归来做，通过中间节点找到二叉搜索树的根节点，然后根据left和right双指针逐层递归构造左右子树。思路:最开始没有判断当当前节点小于最小值时，当前节点的右侧节点的情况，和当前节点大于最大值时，当前节点的左节点的情况，所以出错了，因此要在代码中判断一下这两种情况。思路: 累加树 由题意可知，在二叉搜索树中的递归顺序是右中左的顺序，创建一个新的函数，进行右中左的遍历，在遍历中要将节点的值记录下来，用来做累加。
CSP - J day7
2301_81608637的博客
08-06 189
答案具有单调性：对于正确答案 ans ，小于 ans 的都一定符合条件，大于 ans 的一定不符合条件，因此可以二分答案。先dfs到叶节点，再逐步递归出来，过程中节点数增加，一旦达到 mid ，ans 加一，同时向上贡献节点数变为零。
STC16F单片机GPIO、PWM与编码器详解
3. 舵机和电机PWM控制原理 舵机和电机的PWM控制是基于单片机的数字信号对模拟设备进行精确控制的关键应用。通过改变脉冲的宽度，可以实现电机转速或位置的连续调节。 4. 编码器 编码器是一种测量装置，将机械位移...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值