年后题集2

最新推荐文章于 2024-08-29 19:36:28 发布

weixin_45806916

最新推荐文章于 2024-08-29 19:36:28 发布

阅读量74

点赞数

分类专栏：题

本文链接：https://blog.csdn.net/weixin_45806916/article/details/113918845

版权

大小写转换动态规划数组和矩阵拆分严格递增序列

关键词由CSDN通过智能技术生成

题专栏收录该内容

12 篇文章 0 订阅

订阅专栏

A - Letter
B - Arrays Sum
C - Shifting Stacks
D - Max Median
E - Eastern Exhibition
F - Accidental Victory

好几道题参考了别人的代码🤫

A - Letter

Letter

网上大部分是用DP，我DP不熟练，没想到用 [,ԾㅂԾ,]

我的思路：字符串中一小段字母如果都是大写或者都是小写，那么如果要变化的话，就需要一块变化，所以我用数组存下来了每个字母段的长度，以及标记好大小写，用前缀和来计算某个字母段不变，其前面都变成大写，后面都变成小写的情况。。

#include <iostream>
#include <algorithm>
#include <string>

using namespace std;
/**
 * 判断大小写，大写返回 1，小写返回 0
 */
bool UL(char c)
{
    if (c <= 'Z' && c >= 'A')
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

int main()
{
    int cnt = 0, cntUpOrLow[100005] = {}; // 每一块字母段的字母个数
    int preLowercase[100005] = {}, preCapital[100005] = {}; // 前缀和
    bool a[100005]; // 字母段大小写标记，大写为 1，小写为 0
    char c = 0, p = -1;
    // 输入
    while ((c = getchar()))
    {
        if (c == '\n')
        {
            break;
        }
        int t = UL(c);
        // 计算大小写标记和字母段长度
        if (t != p)
        {
            cnt++;
            a[cnt] = t;
        }
        cntUpOrLow[cnt]++;
        p = t;
    }
    // 计算前缀和
    for (int i = 1; i <= cnt; i++)
    {
        preLowercase[i] = preLowercase[i-1];
        preCapital[i] = preCapital[i-1];
        if (a[i])
        {
            preCapital[i] += cntUpOrLow[i];
        }
        else
        {
            preLowercase[i] += cntUpOrLow[i];
        }
    }
    // 求结果
    int ans = 0x3f3f3f3f;
    for (int i = 1; i <= cnt; i++)
    {
        // x是前面的小写字母的个数，y是后面的大写字母的个数
        int x = preLowercase[i-1];
        int y = preCapital[cnt] - preCapital[i];
        ans = min(x + y, ans);
    }
    cout << ans << endl;
    return 0;
}

B - Arrays Sum

Arrays Sum

手算模拟了几遍之后想到的，假设可以找到符合条件的矩阵，那 $a_i$ 可以拆成 $b_{1i}+b_{2i}+\cdots+b_{mi}$ ，如果 $a_{i+1}≠a_{i}$ ，那么矩阵 $b$ (大写更好，为了符合题目写成了小写) 第 $i$ 列和第 $i + 1$ 列至少有一个数不一样，这样的话， $a$ 中每有一个数字和前一个数字不一样，就需要多一个变化的值，思路由来：

$a$	2	2	3	5	7	11	13	13	17	计数
第一次	2	2	2	2	2	2	2	2	2
第二次	0	0	1	1	1	1	1	1	1
第三次	0	0	0	2	2	2	2	2	2
第四次	0	0	0	0	2	2	2	2	2
$b_{1}$	2	2	3	5	7	7	7	7	7	4
-	-	-	-	-	-	-	-	-	-
第五次	0	0	0	0	0	4	4	4	4
第六次	0	0	0	0	0	0	2	2	2
第七次	0	0	0	0	0	0	0	0	4
$b_{2}$	0	0	0	0	0	4	6	6	10	4

第一轮 k 次，后面还有的话一轮 k-1次(因为前面有0)

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

using namespace std;

int main()
{
    int t, n, k, p = 0, x, cnt, difference[105] = {}; //difference 差分，好像在这没啥用呢，其实可以不用数组，直接一个整型变量就可以实现
    scanf("%d", &t);
    while (t--)
    {
        cnt = 0, p = 0;
        memset(difference, 0, sizeof(difference));
        scanf("%d%d", &n, &k);
        for (int i = 1; i <= n; i++)
        {
            if (i <= n)
            {
                scanf("%d", &x);
            }
            difference[i] = x - p;
            p = x;
            // 特判第一个数是 0
            if (difference[i] > 0 || (difference[i] == 0 && i == 1))
            {
                cnt++;
            }
        }
        //特判无解的情况
        if (k == 1 && cnt > 1)
        {
            printf("-1\n");
        }
        else if (cnt <= k)
        {
            printf("1\n");
        }
        else
        {
            printf("%d\n", ((cnt-k)%(k-1))?((cnt-k)/(k-1)+2):((cnt-k)/(k-1)+1));
        }
    }
    return 0;
}

C - Shifting Stacks

Shifting Stacks

每输入一个数，看前面的数的总和是不是过少，如果过少，后面又不能向前移，那就没办法移动成严格递增的了。

#include <iostream>
#include <algorithm>

using namespace std;

typedef long long ll;

int main()
{
    int t, n, h, flag = 0;
    scanf("%d", &t);
    while (t--)
    {
        ll Sum = 0;
        flag = 0;
        scanf("%d", &n);
        for (int i = 1; i <= n; i++)
        {
            scanf("%d", &h);
            Sum += h;
            // 过少
            if (Sum < i * (i - 1) / 2)
            {
                flag = 1;
            }
        }
        if (flag)
        {
            printf("NO\n");
        }
        else
        {
            printf("YES\n");
        }
    }
    return 0;
}

D - Max Median

Max Median

啊，这个题想了好久，自己写的代码超时，看别人的代码才知道要用二分，刚开始不是很理解为什么可以用二分。

看到这个之后明白的。

关键函数 bool check(int x); 即判断 $x$ 是否是某区间的中位数

for (int i = 1; i <= n; i++)
{
     sum[i] = sum[i-1] + ((num[i]>=x)?1:-1);
}

这是求前缀和：大于等于 $x$ 的赋值1，否则赋值 -1，那么前缀和小于等于 0 时说明此区间 $[1, i]$ 的中位数不可能是 $x$ ，其他区间就要借助 $m i$ 数组

for (int i = 1; i <= n; i++)
{
    mi[i] = (mi[i-1]>sum[i])?sum[i]:mi[i-1];
}

如果所有长度大于等于 k 的区间的和(像上面一样赋值1和-1求得) 都 $\leq$ 0，说明大于等于 $x$ 的数比小于 $x$ 的数少， $x$ 不可能是中位数。此时返回 $f a l s e$ ， $[x, + \infty]$ 上的数都可以排除了。

为什么 $x$ 不是中位数，大于 $x$ 的数就不可能是中位数了？

取 $z \geq x$ ,则所有小于 $x$ 的数赋值 -1，大于等于 $x$ 的数可能为1，也可能为 -1，那和更不可能大于 0了

而如果存在大于 0 的结果，那么所求中位数一定 ≥ $x$ 。此时返回 $t r u e$

为什么存在大于 0 的结果，所求中位数一定 $\geq x$ ？

结果大于 0 时，有可能大于 $x$ 的数比较多，所以该结果对应的区间中位数 ≥ $x$ ，即至少存在一个中位数 $y \geq x$ 既然 $y \geq x$ ，那么可以继续二分下去，找到所求的最大的中位数。

于是问题就是，找到一个数 $x$ ，比 $x$ 大的数都不可能是中位数，而所求最大中位数 $\geq x$ ，即所求最大中位数就是 $x$ ，二分求。

while (l < r)
{
    median = (l+r+1)>>1;
    if (check(median))
    {
        l = median;
    }
    else
    {
        r = median - 1;
    }
}

AC代码

#include <iostream>
#include <algorithm>

using namespace std;

int n, k, num[200005];

bool check(int x)
{
    int sum[200005] = {}, mi[200005] = {0x3f3f3f3f};
    for (int i = 1; i <= n; i++)
    {
        sum[i] = sum[i-1] + ((num[i]>=x)?1:-1);
        mi[i] = (mi[i-1]>sum[i])?sum[i]:mi[i-1];
    }
    for (int i = k; i <= n; i++)
    {
        if (sum[i] > 0 || sum[i] - mi[i-k] > 0)
        {
            return true;
        }
    }
    return false;
}

int main()
{
    int median = 0, maxnum = 0, minnum = 200005;
    scanf("%d%d", &n, &k);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &num[i]);
        if (num[i] > maxnum)
        {
            maxnum = num[i];
        }
        if (num[i] < minnum)
        {
            minnum = num[i];
        }
    }
    int l = minnum, r = maxnum;
    while (l < r)
    {
        median = (l+r+1)>>1;
        if (check(median))
        {
            l = median;
        }
        else
        {
            r = median - 1;
        }
    }
    printf("%d\n", l);
    return 0;
}

E - Eastern Exhibition

Eastern Exhibition

本来思路是对的，但是试过几次才知道错在了存坐标应该用 $long\ long$ 😓

#include <iostream>
#include <algorithm>

using namespace std;

typedef long long ll;

int main()
{
    int t, n;
    ll x[1005], y[1005];
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &n);
        for (int j = 1; j <= n; j++)
        {
            cin >> x[j] >> y[j];
        }
        if (n % 2 == 0)
        {
            sort(x+1, x+n+1);
            sort(y+1, y+n+1);
            cout << (x[(n/2)+1] - x[(n/2)] + 1) * (y[(n/2)+1] - y[(n/2)] + 1) << endl;
        }
        else
        {
            cout << 1 << endl;
        }
    }
    return 0;
}

F - Accidental Victory

Accidental Victory

这道题也折磨了我很长时间，看别人的代码才知道自己理解错题目思路也错了（┭┮﹏┭┮）

参照在这，很巧妙，还可以用二分。

先从小到大排序一下，一个必输的人他前面的人必输。如果前缀和小于下一个数，那么这个人必输，因为他把能赢的都赢了之后是剩下的人里最小的，那他必输。如果用二分的话check函数就判断x后面有没有前缀和小于下一个数的数，有的话说明x必输，否则缩小区间。

比如 1 2 4 5 7
第一轮 [0,3,4,5,7]
第二轮 [0,0,7,5,7]
第3、4、5个人都有可能赢

比如 1 2 4 7 16 18
第一轮 [0,3,4,6,16,18]
第二轮 [0,0,7,6,16,18]
第1、2、3、4个人必输，第5、6个人可能赢，如果最后再加一个人：
1 2 4 7 16 18 100
那么只有最后一个人可能赢

需要注意的是要存下标，输出的时候要根据下标排序。

代码1，耗时少，来自这里（而我写的耗时多了两倍😅）

#include <iostream>
#include <algorithm>
using namespace std;
#define LL long long
const int N = 200010;
int n;
struct node {
    LL val;
    int id;
    bool operator < (const node &rhs) const {
        return val < rhs.val;
    }
}a[N];
int t[N];
void solve()
{
    //input
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i)
        scanf("%lld", &a[i].val), a[i].id = i;
    //solve
    sort(a + 1, a + n + 1);
    LL ans = a[1].val, tmp = a[1].val;
    for (int i = 2; i <= n; ++i) {
        if (tmp < a[i].val) ans = a[i].val;
        tmp += a[i].val;
    }
    int cnt = 0;
    for (int i = 1; i <= n; ++i)
        if (a[i].val >= ans) t[++cnt] = a[i].id;
    sort(t + 1, t + cnt + 1);
    //output
    printf("%d\n", cnt);
    for (int i = 1; i < cnt; ++i)
        printf("%d ", t[i]);
    printf("%d\n", t[cnt]);
}

int main()
{
    int T;
    scanf("%d", &T);
    while (T--) solve();
    return 0;
}

AC代码(没用二分，参考了上面的代码)

#include <iostream>
#include <algorithm>

using namespace std;

typedef long long ll;

struct Person
{
    ll a;     //数量
    int indx; //下标
} p[200005];

bool cmp1 (Person x, Person y)
{
    return x.a < y.a;
}
//根据下标排序
bool cmp2 (Person x, Person y)
{
    return x.indx < y.indx;
}

int main()
{
    int t, n;
    cin >> t;
    while (t--)
    {
        cin >> n;
        for (int i = 1; i <= n; i++)
        {
            cin >> p[i].a;
            p[i].indx = i;
        }
        sort(p + 1, p + n + 1, cmp1);
        ll tmp = p[1].a, Sum = p[1].a;
        for (int i = 2; i <= n; i++)
        {
            if (Sum < p[i].a)
            {
                // i-1必输，存下p[i].a，找到临界值
                tmp = p[i].a;
            }
            Sum += p[i].a;
        }
        for (int i = 1; i <= n; i++)
        {
            // 找到临界值，比他大的都可能赢
            if (p[i].a == tmp)
            {
                cout << n - i + 1 << endl;
                // 用下标排序
                sort(p + i, p + n + 1, cmp2);
                for (; i <= n ; i++)
                {
                    cout << p[i].indx;
                    if (i == n)
                    {
                        cout << endl;
                    }
                    else
                    {
                        cout << " ";
                    }
                }
            }
        }
    }
    return 0;
}

AC代码：二分

#include <iostream>
#include <algorithm>

using namespace std;

typedef long long ll;

ll p[200005], cop[200005], Sum[200005];
int t, n;

bool check(int x)
{
    for (int i = x; i <= n ; i++)
    {
        if (Sum[i] < p[i+1])
        {
            return false;
        }
    }
    return true;
}

int main()
{
    cin >> t;
    while (t--)
    {
        cin >> n;
        for (int i = 1; i <= n; i++)
        {
            cin >> p[i];
            cop[i] = p[i];
        }
        sort(p + 1, p + n + 1);
        for (int i = 1; i <= n; i++)
        {
            Sum[i] = Sum[i-1] + p[i];
        }
        int L = 0, R = n;
        while (L < R)
        {
            int mid = (L+R)>>1;
            if (check(mid))
            {
                R = mid;
            }
            else
            {
                L = mid + 1;
            }
        }
        int cnt = n - L + 1;
        cout << cnt << endl;
        for (int i = 1; i <= n ; i++)
        {
            if (cop[i] >= p[L])
            {
                cout << i;
                cnt--;
                if (cnt)
                {
                    cout << " ";
                }
                else
                {
                    cout << endl;
                    break;
                }
            }
        }
    }
    return 0;
}

AC代码：二分

#include <iostream>
#include <algorithm>

using namespace std;

typedef long long ll;

struct Person
{
    ll a;     //数量
    int indx; //下标
} p[200005];

ll Sum[200005];
int t, n;

bool check(int x)
{
    for (int i = x; i <= n ; i++)
    {
        if (Sum[i] < p[i+1].a)
        {
            return false;
        }
    }
    return true;
}

bool cmp1(Person x, Person y)
{
    return x.a < y.a;
}

bool cmp2(Person x, Person y)
{
    return x.indx < y.indx;
}

int main()
{
    cin >> t;
    while (t--)
    {
        cin >> n;
        for (int i = 1; i <= n; i++)
        {
            cin >> p[i].a;
            p[i].indx = i;
        }
        sort(p + 1, p + n + 1, cmp1);
        for (int i = 1; i <= n; i++)
        {
            Sum[i] = Sum[i-1] + p[i].a;
        }
        int L = 0, R = n;
        while (L < R)
        {
            int mid = (L+R)>>1;
            if (check(mid))
            {
                R = mid;
            }
            else
            {
                L = mid + 1;
            }
        }
        cout << n - L + 1 << endl;
        sort(p + L, p + n + 1, cmp2);
        for (int i = L; i <= n; i++)
        {
            cout << p[i].indx;
            if (i == n)
            {
                cout << endl;
            }
            else
            {
                cout << " ";
            }
        }
    }
    return 0;
}

weixin_45806916

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
年后题集2

A - LetterB - Arrays SumC - Shifting StacksD - Max MedianE - Eastern ExhibitionF - Accidental VictoryA - LetterLetterB - Arrays SumArrays SumC - Shifting StacksShifting StacksD - Max MedianMax MedianE - Eastern ExhibitionEastern ExhibitionF - A.
复制链接

扫一扫