题解报告（CDUT暑期集训——第四场）

最新推荐文章于 2024-10-27 12:59:29 发布
最新推荐文章于 2024-10-27 12:59:29 发布
阅读量85 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/Misuchii/p/11276145.html
版权

题解报告（CDUT暑期集训——第四场）

Problem D. Nothing is Impossible

HDU - 6335

  • 思路：水题 排个序循环判断就出来了

  • AC代码

#include<stdio.h>
#include<iostream>
#include<math.h>
#include<algorithm>
#include<string.h>
#include<queue>
#include<set>
#include<string>
#include<sstream>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;

ll Pow_mod(ll a, ll b, ll c){
    ll ans = 1;
    a %= c;
    while (b){
        if (b & 1) ans = (ans * a) % c;
        a = (a * a) % c;
        b >>= 1;
    }
    return (ans % c);
}

int gcd(int a, int b){
    return b == 0 ? a : gcd(b, a % b);
}

const int N = 110;

int t, n, m, ans;
int a[N], b[N], c[N];

int main(){
    scanf("%d", &t);
    while (t -- ){
        scanf("%d%d", &n, &m);
        for (int i = 1; i <= n; i ++ ){
            scanf("%d%d", &a[i], &b[i]);
            c[i] = a[i] + b[i];
        }
        sort(c + 1, c + n + 1);
        ans = 0;
        for (int i = 1; i <= n; i ++ ){
            if (m > (c[i] - a[i]))
                ans ++;
            m /= c[i];
        }
        printf("%d\n", ans);
    }
    return 0;
}

Problem E. Matrix from Arrays

HDU - 6336

  • 思路：照着题目中给出的代码 打出2L * 2L的表 发现2L * 2L的矩阵被分成了四个L * L的完全相同的矩阵（由于输入的二维坐标数据较大 需要预处理左上角2L * 2L的矩阵 然后计算就是了

  • AC代码

#include<stdio.h>
#include<iostream>
#include<math.h>
#include<algorithm>
#include<string.h>
#include<queue>
#include<set>
#include<string>
#include<sstream>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;

ll Pow_mod(ll a, ll b, ll c){
    ll ans = 1;
    a %= c;
    while (b){
        if (b & 1) ans = (ans * a) % c;
        a = (a * a) % c;
        b >>= 1;
    }
    return (ans % c);
}

int gcd(int a, int b){
    return b == 0 ? a : gcd(b, a % b);
}

const int N = 50;

int t, l, q;
int a[N];
ll M[N][N];

ll calc(int x, int y){
    if (x < 0 || y < 0) return 0;
    return M[2 * l - 1][2 * l - 1] * (x / (2 * l)) * (y / (2 * l)) + M[2 * l - 1][y % (2 * l)] * (x / (2 * l)) + M[x % (2 * l)][2 * l - 1] * (y / (2 * l)) + M[x % (2 * l)][y % (2 * l)];
}

void init(){
    int cursor = 0;
    for (int i = 0; i < (l << 2); i ++ ){
        for (int j = 0; j <= i; j ++ ){
            M[j][i - j] = a[cursor];
            cursor = (cursor + 1) % l;
        }
    }
    for (int i = 0; i < (l << 1); i ++ ){
        for (int j = 0; j < (l << 1); j ++ ){
            if (i) M[i][j] += M[i - 1][j];
            if (j) M[i][j] += M[i][j - 1];
            if (i && j) M[i][j] -= M[i - 1][j - 1];
        }
    }
}

int main(){
    scanf("%d", &t);
    while (t -- ){
        scanf("%d", &l);
        for (int i = 0; i < l; i ++ ) scanf("%d", &a[i]);
        init();
        scanf("%d", &q);
        while (q -- ){
            int x0, y0, x1, y1;
            scanf("%d%d%d%d", &x0, &y0, &x1, &y1);
            printf("%lld\n", calc(x1, y1) - calc(x1, y0 - 1) - calc(x0 - 1, y1) + calc(x0 - 1, y0 - 1));
        }
    }
    return 0;
}

Problem J. Let Sudoku Rotate

HDU - 6341

  • 思路：dfs 枚举每个4 * 4 sudoku（老郭（不 矩阵旋转次数

  • AC代码

#include<stdio.h>
#include<iostream>
#include<math.h>
#include<algorithm>
#include<string.h>
#include<queue>
#include<set>
#include<string>
#include<sstream>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;

ll Pow_mod(ll a, ll b, ll c){
    ll ans = 1;
    a %= c;
    while (b){
        if (b & 1) ans = (ans * a) % c;
        a = (a * a) % c;
        b >>= 1;
    }
    return (ans % c);
}

int gcd(int a, int b){
    return b == 0 ? a : gcd(b, a % b);
}

const int N = 20;
const int M = 10;
const int INF = 0x3f3f3f3f;

int t, ans;
int a[80];
char mp[N][N], tmp[M][M];

void rot(int x, int y){
    for (int i = 0; i < 4; i ++ )
        for (int j = 0; j < 4; j ++ )
            tmp[i][j] = mp[4 * x - j - 1][4 * y + i - 4];
    for (int i = 0; i < 4; i ++ )
        for (int j = 0; j < 4; j ++ )
            mp[4 * x + i - 4][4 * y + j - 4] = tmp[i][j];
}

bool judge(int x, int y){
    for (int i = 4 * x - 4; i < 4 * x; i ++ ){
        memset(a, 0, sizeof(a));
        for (int j = 0; j < 4 * y; j ++ ){
            if (a[int(mp[i][j])] > 0) return false;
            a[int(mp[i][j])] ++;
        }
    }
    for (int i = 4 * y - 4; i < 4 * y; i ++ ){
        memset(a, 0, sizeof(a));
        for (int j = 0; j < 4 * x; j ++ ){
            if (a[int(mp[j][i])] > 0) return false;
            a[int(mp[j][i])] ++;
        }
    }
    return true;
}

void dfs(int x, int y, int tot){
    if (tot >= ans) return ;
    if (x == 5){
        ans = min(ans, tot);
        return ;
    }
    if (y == 5){
        dfs(x + 1, 1, tot);
        return ;
    }
    for (int i = 0; i < 4; i ++ ){
        if (judge(x, y)) dfs(x, y + 1, tot + i);
        rot(x, y);
    }
}

int main(){
    scanf("%d", &t);
    while (t -- ){
        ans = INF;
        for (int i = 0; i < 16; i ++ ) scanf("%s", mp[i]);
        dfs(1, 1, 0);
        printf("%d\n", ans);
    }
    return 0;
}

Problem K. Expression in Memories

HDU - 6342

  • 思路：纯模拟 有一说一 模拟题脑壳痛（用递归优化了而已（然并卵

  • AC代码

#include<stdio.h>
#include<iostream>
#include<math.h>
#include<algorithm>
#include<string.h>
#include<queue>
#include<set>
#include<string>
#include<sstream>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;

ll Pow_mod(ll a, ll b, ll c){
    ll ans = 1;
    a %= c;
    while (b){
        if (b & 1) ans = (ans * a) % c;
        a = (a * a) % c;
        b >>= 1;
    }
    return (ans % c);
}

int gcd(int a, int b){
    return b == 0 ? a : gcd(b, a % b);
}

const int N = 510;

int t;
char s[N];

bool judge(char c){
    if (c == '+' || c == '*') return true;
    return false;
}

bool flag(int l, int r){
    if (l == r) return true;
    if (l > r) return false;
    if (s[l] != '0') return true;
    if (s[l + 1] != '?') return false;
    s[l + 1] = '+';
    return flag(l + 2, r);
}

bool dfs(int l, int r){
    if (l > r) return false;
    bool flag1, flag2;
    for (int i = l; i <= r; i ++ ){
        if (judge(s[i])){
            flag1 = dfs(l, i - 1);
            flag2 = dfs(i + 1, r);
            return flag1 && flag2;
        }
    }
    return flag(l, r);
}

int main(){
    scanf("%d", &t);
    while (t -- ){
        scanf("%s", s);
        if (dfs(0, strlen(s) - 1)){
            for (int i = 0; i < strlen(s); i ++ )
                if (s[i] == '?') s[i] = '1';
            printf("%s\n", s);
        }
        else printf("IMPOSSIBLE\n");
    }
    return 0;
}

Problem L. Graph Theory Homework

HDU - 6343

  • 思路：水题（没加abs贡献一发wa（该打

  • AC代码

#include<stdio.h>
#include<iostream>
#include<math.h>
#include<algorithm>
#include<string.h>
#include<queue>
#include<set>
#include<string>
#include<sstream>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;

ll Pow_mod(ll a, ll b, ll c){
    ll ans = 1;
    a %= c;
    while (b){
        if (b & 1) ans = (ans * a) % c;
        a = (a * a) % c;
        b >>= 1;
    }
    return (ans % c);
}

int gcd(int a, int b){
    return b == 0 ? a : gcd(b, a % b);
}

template <class T>

inline bool scan_d(T &ret){
     char c;
     int sgn;
     if (c = getchar(), c = EOF) return 0; // EOF
     while (c != '-' && (c < '0' || c > '9')) c = getchar();
     sgn = (c == '-') ? -1 : 1;
     ret = (c == '-') ? 0 : (c - '0');
     while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
     ret *= sgn;
     return 1;
}

inline void out(int x){
    if (x > 9) out(x / 10);
    putchar(x % 10 + '0');
}

const int N = 1e5 + 10;

int t;
ll n, ans;
int w[N];

int main(){
    scanf("%d", &t);
    while (t -- ){
        scanf("%lld", &n);
        for (int i = 1; i <= n; i ++ ) scanf("%d", &w[i]);
        ans = abs(w[n] - w[1]);
        printf("%lld\n", (ll)sqrt(ans));
    }
    return 0;
}

转载于:https://www.cnblogs.com/Misuchii/p/11276145.html

weixin_30594001
关注
典型题解——第14章　网络函数-教程与笔记习题
05-19
由于无法提供具体的习题题解内容，上述的知识点是根据标题“典型题解——第14章 网络函数-教程与笔记习题”推测出的可能出现在该章内容中的一些网络函数相关知识点。在实际的学习和复习中，应当结合具体的教材和课堂...
题解报告（CDUT暑期集训——第一场）
weixin_30594001的博客
07-19 131
题解报告（CDUT暑期集训——第一场） A - Maximum Multiple HDU - 6298 思路：先按照题意打表 发现规律 就出来了（最开始没开long long贡献了3发 然后又忘了换行又贡献了一发 AC代码 #include<bits/stdc++.h> typedef long long ll; typedef unsigned long long ...
题解报告（CDUT暑期集训——第三场）
weixin_30594001的博客
07-21 100
题解报告（CDUT暑期集训——第三场） A - Problem A. Ascending Rating HDU - 6319 思路：单调队列板子题？（但是弱的一批的我还是不会用（有空补上 用的滑动窗口算法 按着题解的从后往前做（ps：菜是原罪 AC代码 #include<stdio.h> #include<iostream> #include<mat...
题解报告（CDUT暑期集训——第六场）
weixin_30594001的博客
07-31 101
题解报告（CDUT暑期集训——第六场） A - oval-and-rectangle HDU - 6362 思路：水题 积分一化就出来了 AC代码 #include<stdio.h> #include<iostream> #include<math.h> #include<algorithm> #include<string....
题解报告（CDUT暑期集训——第五场）
weixin_30594001的博客
07-31 91
题解报告（CDUT暑期集训——第五场） B - Beautiful Now HDU - 6351 思路：直接暴力全排列就行了 最多\(10!\)次 题目限制2500ms 全排列大概是2000多ms（最开始数组开的20疯狂t 结束前十几秒听到尧神说把数组开小过了就马上改了一交过了（%%尧神 时间卡的太死了（ AC代码 #include<stdio.h> #includ...
题解报告（CDUT暑期集训——第二场）
weixin_30594001的博客
07-19 98
题解报告（CDUT暑期集训——第二场） D - Game HDU - 6312 思路：水题 Alice一直是必胜态 AC代码 #include<stdio.h> #include<iostream> #include<math.h> #include<algorithm> #include<string> #includ...
全国卷历史第41题解题指导与训练——十自拟论题类.doc
10-12
【全国卷历史第41题解题指导与训练——十自拟论题类】 全国卷历史第41题是一项旨在考查学生学科核心素养的高难度试题。它要求考生基于提供的信息，独立思考，提出自己的论题，并进行论述。试题的设计体现了“稳中...
【PAT-B1012】数字分类——c++满分题解（csdn）————程序.pdf
12-04
- 使用变量`c1`记录A2类别的正负状态，初始设为-1，确保第一项加上的数是正确的。 - 使用变量`c2`记录A4类别的计数，初始设为0。 - 对于输入的每一个整数`t`，根据`t`对5取模的值`z`进行分类处理： - `z == 0`时...
【PAT-B1063 谱半径——c++满分题解】（csdn）————程序.pdf
12-04
它指的是图的邻接矩阵中第二大特征值与最大特征值之差的绝对值。在本题目中，虽然没有直接涉及图论的谱半径，但从标题和描述来看，这可能是一个与数值计算或算法有关的编程问题。 题目描述的是一个简单的输入处理和...
二叉树习题其六【力扣】【算法学习day.13】
2301_79232523的博客
10-25 571
书接上篇文章二叉树习题其四，这篇文章我们将基础拓展###我做这类文档一个重要的目的还是给正在学习的大家提供方向（例如想要掌握基础用法，该刷哪些题？）我的解析也不会做的非常详细，只会提供思路和一些关键点，力扣上的大佬们的题解质量是非常非常高滴！！！
代码随想录训练营第二十一天|669. 修剪二叉搜索树、108.将有序数组转换为二叉搜索树、538.把二叉搜索树转换为累加树
qq_43487696的博客
10-22 233
【代码】代码随想录训练营第二十一天|669. 修剪二叉搜索树、108.将有序数组转换为二叉搜索树、538.把二叉搜索树转换为累加树。
从零开始的LeetCode刷题日记：35. 分发糖果
chenjialehhh的博客
10-26 146
这道题的核心思想是分而治之！如果一开始就想着同时考虑一个小朋友的两边，那么很容易顾此失彼。我们可以先从前往后来确保这个方向的糖果数是符合题意的，然后再从后往前比较一次来确保另一个方向也符合题意，最后二者取最大值就同时满足了两边的需求。这里要注意的是，从前往后遍历的时候，比较的是i+1是否大于i，因为这有这样才能用到前面遍历得到的结果，逐步累加。同理，从后往前遍历比较的是i-1是否大于i。
Linux的调度算法
sswithyou的博客
10-24 932
这个是我们Linux系统的runqueue，听名字就知道，这个就是调度运行中的程序的，也就是管理进程的一个队列，我们看到红圈里，有个queue[140],这个queue一共有140 个元素，前一百个是其他种类进程应用的，这些进程优先级大于我们要运行的程序，他们会保护电脑的安危，前一百个我们现在不用管，以后学习到了再说，后四十个，四十这个正好和nice的那[-20,19]的取值范围正好对应，就是保存了四十个PCB--task_struct ,都是对进程的描述，也就是每个进程的结构体。这样做的意义是什么？
列表、元组、集合、字典和 pandas 数据框（DataFrame）之间的数据转换
qq_44133607的博客
10-23 583
Python 中的列表、元组、集合、字典和数据框之间可以通过内置的函数和方法方便地相互转换。在实际应用中，不同的数据结构有不同的使用场景，灵活转换可以使得数据处理更加简便。通过pandas数据框可以实现与表格型数据的互操作，而通过列表、元组和集合可以实现不同的数据存储和操作方式。
C++ | Leetcode C++题解之第502题IPO
Ddddddd_158的博客
10-23 372
C++ | Leetcode C++题解之第502题IPO
LeetCode199. 二叉树的右视图（2024秋季每日一题 47）
学习笔记
10-24 440
给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。输入: [1,2,3,null,5,null,4]二叉树的节点个数的范围是 [0,100]输入: [1,null,3]输出: [1,3,4]
【深搜算法】（第四篇）
最新发布
weixin_73861555的博客
10-27 899
然⽽，通过观察我们可以发现，如果我们先删除最底部的叶⼦节点，然后再处理删除后的节点，最终的结果并不会受到影响。因此，在处理完⼦节点后，我们仍然需要处理当前节点。3. 函数作⽤：整合⽗节点的信息与当前节点的信息计算当前节点数字，并向下传递，在回溯时返回当前⼦树（当前节点作为⼦树根节点）数字和。前序遍历按照根节点、左⼦树、右⼦树的顺序遍历⼆叉树的所有节点，通常⽤于⼦节点的状态依赖于⽗节点状态的题⽬。后序遍历按照左⼦树、右⼦树、根节点的顺序遍历⼆叉树的所有节点，通常⽤于⽗节点的状态依赖于⼦节点状态的题⽬。
101链表指定区间反转
qq_64657314的博客
10-25 210
牛客101链表指定区间反转
牛客暑期集训营第八场：算法题解概览与策略分析
在2020牛客多校暑期集训营第八场的题解文档中，涉及了多个编程题目，主要集中在C++语言的应用上。以下是各题目的简要概述和解题思路： 1. A-All-StarGame: 题目要求在给定数组中选择数字，目标是使得最后选出的数字...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值