4.1刷题记录

最新推荐文章于 2024-11-07 23:35:47 发布
最新推荐文章于 2024-11-07 23:35:47 发布
阅读量357 收藏
点赞数
分类专栏： 补题日记 文章标签： 数据结构 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50007959/article/details/123892925
版权

波动数列

在这里插入图片描述

int dp[1005][1005];

int mood(int n, int m){
    return (n % m + m) % m;//求正余数
}

int main() {
	IOS;
	// freopen("P1908_6.in","r",stdin);//读入数据
	// freopen("P1908.out","w",stdout); //输出数据
    int n, s, a, b;
    cin >> n >> s >> a >> b;
    s %= n, a %= n, b %= n;
    dp[0][0] = 1;
    for (int i = 1; i <= n; ++i){
        for (int j = 0; j < n; ++j){
            dp[i][j] = (dp[i - 1][mood(j - a * i, n)] + dp[i - 1][mood(j + b * i, n)]) % mod;
        }
    }
    cout << dp[n - 1][mood(s, n)];//因为第一个x也是一个数
    return 0;
}

1、如果全部都是加减，那么可以先mod
2、 一看就会超时或者是明显写进dp就会超时的的数可以考虑找规律
3、 能写成等式意味着可以去掉一些东西，可以改变形式求所需的
4、 虽然不是等价变换但是含义是一样的，就可以朝看着比较舒服的等式取转变
5、dp[0][0]就是边界，是一个都不取时的方案，而例如dp[0][1]是不合法方案为0

外卖店优先级

模拟还是要按标准做法做才最稳妥，下面这个交了很多次要么卡5要么卡8（ac了)
模拟题伪代码比较重要

vector<int> v[maxn];
vector<int> ans;

int main() {
	IOS;
	//对每一个分别计算
    int n, m, t;
    cin >> n >> m >> t;

    for (int i = 0; i < m; ++i){
        int ts, id;
        cin >> ts >> id;
        v[id].push_back(ts);
    }
    
    for (int i = 1; i <= n; ++i){
        if(v[i].size() == 0) continue;
        int pre = 0;
        sort(v[i].begin(), v[i].end());
        int tans = 0;
        bool flag = false;
        for (int j = 0; j < v[i].size(); ++j){
            if(pre == 0) {
                pre = v[i][j];
                tans = 2;
                continue;
            }
            
            if(pre != v[i][j]) {
                int temp = v[i][j] - pre - 1;
                tans -= temp;
            }
            
            if(tans < 0)
                tans = 0;
            
            if(tans > 5)
                flag = true;
            else if(flag && tans <= 3)
                flag = false;
            
            tans += 2;
            pre = v[i][j];

            if(tans > 5)//看了讨论，一个数小于一个点优先级本来大于5减到了2，此时应该出来，但是我先加了此位置的数值，导致这个数大于3了就出不来了
                flag = true;
            else if(flag && tans <= 3)
                flag = false;
        }
        if(t - pre > 0) {
            tans -= t - pre;
            if(tans < 0){
                tans = 0;
            }
            if(tans <= 3) 
                flag = false;
        }
        if(tans <= 3) //所以这有2个判的
                flag = false;
        if(tans > 5 || flag)
            ans.push_back(i);
    }
    cout << ans.size();
    return 0;
}

标准

pair<int, int> p[maxn];
bool st[maxn];
int score[maxn], last[maxn];

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

    for (int i = 0; i < m; ++i){
        cin >> p[i].first >> p[i].second;
    }
    sort(p, p + m);
    for (int i = 0; i < m; ){
        int j = i;
        while(j < m && p[j] == p[i])
            ++j;
        int t = p[i].first, id = p[i].second, cnt = j - i;
        i = j;
//---------------------------上面那个处理很典
        score[id] -= t - last[id] - 1;
        if(score[id] < 0)
            score[id] = 0;
        if(score[id] <= 3)
            st[id] = false;

        score[id] += cnt * 2;
        if(score[id] > 5)//实际也是判了两次，我这里没考虑到
            st[id] = true;
        last[id] = t;
    }
     for (int i = 1; i <= n; i ++ )
        if (last[i] < t){
            score[i] -= t - last[i];
            if (score[i] <= 3) st[i] = false;
        }

    int res = 0;
    for (int i = 1; i <= n; i ++ ) res += st[i];

    printf("%d\n", res);
        return 0;
}

航班时间

我从数字时间猜出来 / 2的…
这居然是可以推的小学奥数题
题： 船速水速木块
这个： 相差 - 时差 + 相差 + 时差 = 2 * 时差

int get_seconds(int h, int m, int s){
    return h * 3600 + m * 60 + s;
}

int get_time(){
    string s;
    getline(cin, s);
    if(s.back() != ')')
        s += " (+0)";
    int h1, m1, s1, h2, m2, s2, d;
    sscanf(s.c_str(), "%d:%d:%d %d:%d:%d (+%d)", &h1, &m1, &s1, &h2, &m2, &s2, &d);
    return get_seconds(h2, m2, s2) - get_seconds(h1, m1, s1) + d * 24 * 3600;
}

int main() {
	IOS;
    int t;
    cin >> t;
    string s;
    getline(cin, s);
    while(t--){
        int time = (get_time() + get_time()) / 2;
        int hour = time / 3600, minute = time % 3600 / 60, second = time % 60;
        printf("%02d:%02d:%02d\n", hour, minute, second);
    }
    return 0;
}

对于换行还是用getline保险一点，getchar()会出错
关于时间：转换成秒更方便
c_str(): char 形式表现的字符串，放sscanf的第一位
关于sscanf() : 1 2

逆序对的数量

在这里插入图片描述
sort写习惯了，除了考试前后排序都不会写orz

计算逆序对的数量（序列）：

  1. 递归算左边的；
  2. 递归算右边的；
  3. 算一个左一个右的；
  4. 把他们加到到一起。

这个时候我们注意到一个很重要的性质，左右半边的元素在各自任意调换顺序，是不影响第三步计数的链接

裸的归并排序，从那个性质中推出来的res，还是不太会
归并视频

const int N = 1e6 + 10;
int cmp[N];
long long int res = 0;
int q[N];
 
void merge_sort(int l, int r){
    if (l >= r) return;
    int mid = l + r >> 1;
    merge_sort(l, mid), merge_sort(mid + 1, r);
    int i = l, j = mid + 1,k = 0;

    while (i <= mid && j <= r){
        if (q[i] <= q[j]){
            cmp[k] = q[i];
            ++k, ++i;
        }
        else{
            res += mid - i + 1;
            cmp[k] = q[j];
            ++k, ++j;
        }
    }
//因为两个指针
    while (i <= mid) {
        cmp[k] = q[i];
        ++k, ++i;
    }
    while (j <= r) {
        cmp[k] = q[j];
        ++k, ++j;
    }
    
    for (int i = l, j = 0; i <= r; i ++, j ++) q[i] = cmp[j];//还原
}

int main(){
    int n;
    cin >> n;
    for (int i = 0; i < n; i ++) scanf("%d", &q[i]);
    merge_sort(0, n - 1);
    cout << res << endl;
    return 0;
}

雷达设备

我觉得我的思路没问题啊，就是wa就是wa，我还特地证明了一下…
下面是ac代码，因为（我也不知道为什么要这样）
在这里插入图片描述

    cin >> n >> r;
    for (int i = 0; i < n; ++i){
        int x, y;
        cin >> x >> y;
        if(abs(y) > r) {
            cout << -1;
            return 0;
        }
        p[i].second = x - sqrt(r * r - y * y);
        p[i].first = x + sqrt(r * r - y * y);
    }
    sort(p, p + n);
    int ans = 0;
    for (int i = 0; i < n; ){
        int j = i + 1;
        for (; j < n;){
            if(p[j].second <= p[i].first)
                ++j;
            else
                break;
        }
        i = j;
        ++ans;
    }
    cout << ans;
    return 0;
}

付账问题

推出来了平均，但是方向错了，居然去考虑小于avr的正常，大于的取它的0.00001附近，卡这了orz
应该是把不够的数往后面填，这样也能使后面的数的差值变小

long double 输出只能用%Lf

int a[maxn];

int main() {
	IOS;
	// freopen("P1908_6.in","r",stdin);//读入数据
	// freopen("P1908.out","w",stdout); //输出数据
    ll n;
    long double s;
    cin >> n >> s;
    for(int i = 0; i < n; ++i){
        cin >> a[i];
    }
    sort(a, a + n);
    long double ans = 0, avr = s / n;
    for(int i = 0; i < n; ++i){
        long double temp = s / (n - i);
        if(a[i] < temp) temp = a[i];
        s -= temp;
        ans += (avr - temp) * (avr - temp);
    }
    printf("%.4Lf", sqrt(ans / n));
    return 0;
}

糖果

背包是选择模型， 把很多同类的事物分到一块
背包问题一般第一维是数量，第二维是限制
能优化成一维的是因为单调

后一个状态方程推错了，搅起了

int dp[105][105];

int mood(int x, int k){
    return (x % k + k) % k;
}

int main() {
	IOS;
	// freopen("P1908_6.in","r",stdin);//读入数据
	// freopen("P1908.out","w",stdout); //输出数据
    int n, k;
    cin >> n >> k;
    remin(dp);//不这样就会出错 应该是因为余数的计算，下次直接初始化就行了
    dp[0][0] = 0;
    for(int i = 1; i <= n; ++i){
        int w;
        cin >> w;
        for(int j = 0; j < k; ++j){
            dp[i][j] = max(dp[i - 1][j], dp[i - 1][mood(j + w, k)] + w);
            //dp[i][j] = max(dp[i - 1][j],  dp[i - 1][(j + k - w % k) % k] + w);
        }
    }
    cout << dp[n][0];
    return 0;
}

小沙好难哄啊

蛀牙牙乐
关注
专栏目录
Java基础知识（牛客刷题）记录..(持续输出中)
Kingwe19的博客
10-15 828
Java 重写(Override)与重载(Overload) 重写(Override) 重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！ 重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。 重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如： 父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception
Leetcode刷题记录
Yang_Chen_xi的博客
08-02 814
leetcode记录
LeetCode刷题记录
qq_43585641的博客
02-19 1674
刷题记录，包括不限于每日一题
2024.（3.30和4.1）力扣刷题记录-二叉树学习记录2
lshx4658的博客
03-30 540
递可以不用每次都更新v值，因为从上到下能确保最大小值就是该条路径的，而没有受其他路径影响；而归每次都需更新v值，一个节点有左右两边两条路径到达。学习一下灵神的写法，来自视频。不会，来自视频代码。不会，全都来自灵神题解（
算法刷题记录2
qq_64064246的博客
04-16 1162
每次都在已经解锁 (当前手上有的钱大于某个项目的花费，该项目就算是被解锁)了的项目中选一个利润最大的项目。要注意的是，每次做完一次项目，手头上的钱就变为：之前的钱+本次项目的利润。因此本题就是从边界上的O开始递归，找与边界O联通的O，并标记为#（代表已遍历），最后图中剩下的O就是：被X包围的O。如果我每次移动都遵守这个规律，每次要移动大盘的时候，就把上面的小盘全部移都，把大盘空出来，这次移动就保证了大盘一定不会叠着小盘，且大盘在小盘下。当前加入的元素，就是比栈顶弹出的元素大且离它最近的元素。
leetcode刷题记录
pxyp123的博客
03-09 1129
leetcode刷题记录
算法笔记刷题记录
gzjyyds的博客
10-08 601
我的算法笔记刷题记录
leetcode数据库刷题记录
weixin_41391619的博客
12-12 698
1.找出某特征连续出现n次的所有记录 题目要求： id和people都是int类型，visit_date是日期类型，id是主键 方法一：使用rank() 思路分析： 将people>=100的所有id进行排序（由于本例中id是主键，所以肯定不会有重复，因此直接使用rank就可以）；然后用id值减去rank值，结果记为c，如果id是连续的，那么连续id对应c应该是相同的；c出现了几次，那么id就连续了c条记录。 with t1 as( select id,visit_date,people,
3.29-4.17刷题记录
hannah2233的博客
04-17 1050
2022.3.29 一、 LRU缓存淘汰算法 面试题 16.25. LRU 缓存 剑指 Offer II 031. 最近最少使用缓存 /** * @param {number} capacity */ var LRUCache = function(capacity) { this.capacity = capacity; this.map = new Map(); }; /** * @param {number} key * @return {number} */ LRUCa
leetcode气温-LeetCode:记录自己的C语言(purec)leetcode刷题之路，贵在坚持
07-01
记录自己的刷题之路，贵在坚。 1 前缀和与差分 1.1 简介 1.2 典型题目 2 双指针 2.1 简介 2.2 典型题目 3 并查集 3.1 简介 3.2 典型题目 4 单调栈与单调队列 4.1 简介 4.2 典型题目 5 二叉树 5.1 简介 5.2 典型题目 ...
SQL 50题刷题记录
qq_36684096的博客
05-04 400
上诉为数据表 答: 1 select * from student right join ( select t1.sid,class1,class2 from (select sid,score as class1 from sc where cid=‘01’)as t1, (select sid,score as class2 from sc where cid=‘02’)as t2 whe...
【牛客刷题】数据库专项错题记录三
maplepiece1999的博客
09-20 2552
1.查询显示雇员的姓名和姓名中是否含有字母A的信息，满足如下条件 如果字符A在姓名的首位，则显示’字符A在首位’ 如果字符A在姓名的末位，则显示’字符A在末位’ 如果字符A在姓名中不存在，则显示’没有字符A’ 其他情况显示’字符A在中间’ 下列操作语句正确的是 select ename, case charindex(‘A‘,ename) when 1 then ‘字符A在首位‘ when len(ename) then ‘字符A在末位‘ when 0 then ‘没有字符A‘ else ‘字符A在中间‘
【算法与数据结构】【链表篇】【题1-题5】
handsomethefirst的博客
11-07 502
题目：输入一个链表的头结点，从尾到头反过来打印出每个节点的值。思路：要反过来打印，首先需要遍历，那么从先遍历的节点后打印，典型的后进先出，符合栈的结构。
《数据结构与算法》二叉树基础OJ练习
2301_79722165的博客
11-05 240
学习了二叉树之后，来做点关于二叉树的基础题
数据结构(C语言版)-1.线性表
yang_pi_pi的博客
11-07 840
胡元义，黑新宏 数据结构教程-》 第2章 线性表
数据结构C语言描述2(图文结合)--有头单链表，无头单链表(两种方法)，链表反转、有序链表构建、排序等操作，考研可看
最新发布
weixin_74085818的博客
11-07 681
链表由一系列不必存在内存中连续的空间的结构组成；每一个结构都有包含元素的`数据域`和指向下一个节点的`指针域`，指针域存储指向下一个节点的指针，最后一个元素的指针指向为`NULL`。
数据结构计算二叉树节点的个数
qq_45153375的博客
11-07 193
因此，这棵树中度为0的节点数 ( n_0 = 4 )，度为1的节点数 ( n_1 = 3 )。因此，这棵树中度为0的节点数 ( n_0 = 6 )，度为2的节点数 ( n_2 = 5 )。因此，这棵树的总节点数是 18，度为2的节点数 ( n_2 = 7 )。以下是几道练习题帮助理解如何计算度为1和度为0的节点数量。
数据结构 | 第四章 | 栈和队列
ZJC744575的博客
11-07 184
只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出。：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。LIFO（Last In First Out）的原则。：栈的插入操作叫做进栈/压栈/入栈，：栈的删除操作叫做出栈。
labuladong算法秘籍V4.1：刷题全家桶与核心技术解析
"labuladong的算法秘籍V4.1.pdf" 是一本专注于提升编程技能，特别是算法和数据结构学习的指南。该书以实战为导向，适合各个层次的程序员，从新手入门到进阶学习者都能从中受益。作者通过丰富的实例和讲解，将复杂的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值