Codeforces Round #339 (Div. 1) ABC

最新推荐文章于 2023-06-05 09:00:00 发布
最新推荐文章于 2023-06-05 09:00:00 发布
阅读量582 收藏
点赞数
分类专栏： 解题报告 文章标签： codeforces Round-#339
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/squee_spoon/article/details/50527889
版权

A Peter and Snow Blower

多边形与中心最远距离作大圆，最近距离作小圆，答案是大圆面积减去小圆面积。检查下中心是否在多边形内，如果在最近距离就是0。注意最远距离只会出现在点上，而最近距离可能出现在点上和边上。这题没什么意思，就是贴下计算几何模板。

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

    class Point {
        double x;
        double y;

        Point(double x, double y) {
            this.x = x;
            this.y = y;
        }

        double Cross(Point point) {
            return x * point.y - y * point.x;
        }

        double Dot(Point point) {
            return x * point.x + y * point.y;
        }

        double Distance(Point point) {
            return Math.sqrt((x - point.x) * (x - point.x) + (y - point.y)
                    * (y - point.y));
        }

        Point Sub(Point point) {
            return new Point(x - point.x, y - point.y);
        }
    }

    int n;
    Point pt;
    Point[] pts;

    void Solve() {

        FastScanner scan = new FastScanner();
        n = scan.nextInt();

        int px = scan.nextInt();
        int py = scan.nextInt();
        pt = new Point(px, py);
        pts = new Point[n + 1];

        for (int i = 0; i < n; i++) {
            int x = scan.nextInt();
            int y = scan.nextInt();
            pts[i] = new Point(x, y);
        }
        pts[n] = pts[0];

        boolean positive = false;
        boolean negative = false;
        for (int i = 0; i < n; i++) {
            Point vec = pts[i + 1].Sub(pts[i]);
            double X = vec.Cross(pt.Sub(pts[i]));
            if (X < 0) {
                negative = true;
            }
            if (X > 0) {
                positive = true;
            }
        }

        double maxDist = 0;
        double minDist = Double.MAX_VALUE;
        if (!(positive && negative)) {
            minDist = 0;
        }
        for (int i = 0; i < n; i++) {
            double p2p = pt.Distance(pts[i]);
            maxDist = Math.max(maxDist, p2p);
            minDist = Math.min(minDist, p2p);
            double a = pts[i].Distance(pts[i + 1]);
            double b = pts[i].Distance(pt);
            double c = pts[i + 1].Distance(pt);
            double p = (a + b + c) / 2;
            double S = Math.sqrt(p * (p - a) * (p - b) * (p - c));
            double p2l = S * 2 / a;
            if (pt.Sub(pts[i]).Dot(pts[i + 1].Sub(pts[i]))
                    * pt.Sub(pts[i + 1]).Dot(pts[i].Sub(pts[i + 1])) >= 0)
                minDist = Math.min(minDist, p2l);
        }
        double ans = Math.PI * (maxDist * maxDist - minDist * minDist);
        System.out.print(ans);
    }

    public static void main(String[] args) {
        new Main().Solve();
    }

    public static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(String s) {
            try {
                br = new BufferedReader(new FileReader(s));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public FastScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String nextToken() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        public boolean EOF() {
            if (st != null && st.hasMoreTokens()) {
                return false;
            } else {
                String line = null;
                try {
                    line = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (line == null)
                    return true;
                st = new StringTokenizer(line);
                return false;
            }
        }

        int nextInt() {
            return Integer.parseInt(nextToken());
        }

        long nextLong() {
            return Long.parseLong(nextToken());
        }

        double nextDouble() {
            return Double.parseDouble(nextToken());
        }
    }
}

B Skills

首先排序，然后枚举加满的技能的数量。对于每次枚举，用二分计算能把最低级的技能加到多少，取一个总分的最大值即可。写的时候要细心，不然容易出bug。
另外，原本以为加满技能的数量->总分是一个凸函数，写了个三分套二分一直WA。后来把三分作了些修改，当区间小到一定程度时改为枚举过掉了(实际上姿势还是不对的)。。因为后来事实证明那不一定是凸函数。写完以后还有个发现，自变量离散(因为只能取整数)和连续的三分是有区别的。

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {
    class Node implements Comparable<Node> {
        long val;
        int id;

        @Override
        public int compareTo(Node o) {
            // TODO Auto-generated method stub
            if (val < o.val) {
                return -1;
            } else if (val == o.val) {
                return 0;
            } else {
                return 1;
            }
        }
    }

    int n;
    long A, cf, cm;
    long m;
    Node[] a;
    long[] rsum;
    long[] lsum;

    long BinerySearch(int l, int r, long val) {
        int mid;
        int pos = 0;
        while (l <= r) {
            mid = (l + r) >> 1;
            if (lsum[mid] <= val) {
                pos = mid;
                l = mid + 1;
            } else {
                r = mid - 1;
            }
        }
        val -= lsum[pos];
        long res = a[pos].val + val / (pos + 1);
        res = Math.min(res, A);
        return res;
    }

    void Solve() {
        FastScanner scan = new FastScanner();
        n = scan.nextInt();
        A = scan.nextLong();
        cf = scan.nextLong();
        cm = scan.nextLong();
        m = scan.nextLong();
        a = new Node[n + 1];
        lsum = new long[n + 1];
        rsum = new long[n + 1];

        for (int i = 0; i < n; i++) {
            a[i] = new Node();
            a[i].val = scan.nextLong();
            a[i].id = i;
        }

        Arrays.sort(a, 0, n);

        for (int i = 1; i < n; i++) {
            lsum[i] = lsum[i - 1] + (a[i].val - a[i - 1].val) * i;
        }
        lsum[n] = Long.MAX_VALUE;

        int leftMost = 0;
        for (int i = n - 1; i >= 0; i--) {
            rsum[i] = rsum[i + 1] + (A - a[i].val);
            if (rsum[i] > m) {
                leftMost = i + 1;
                break;
            }
        }

        long maxP = 0;
        int left = leftMost;
        long MIN = A;
        for (int i = n; i >= leftMost; i--) {
            long mm = m - rsum[i];
            long tmp = BinerySearch(0, i - 1, mm);

            long power = tmp * cm + (n - i) * cf;
            if (tmp == A) {
                power = A * cm + n * cf;
            }
            if (power >= maxP) {
                maxP = power;
                left = i;
                MIN = tmp;
            }
        }

        long[] ans = new long[n + 1];
        for (int i = 0; i < n; i++) {
            int id = a[i].id;
            ans[id] = a[i].val;
            if (i >= left) {
                ans[id] = A;
            } else if (ans[id] < MIN) {
                ans[id] = MIN;
            }
        }

        PrintWriter out = new PrintWriter(System.out);
        out.println(maxP);
        for (int i = 0; i < n; i++) {
            out.print(ans[i] + " ");
        }
        out.println();
        out.flush();
    }

    public static void main(String[] args) {
        new Main().Solve();
    }

    public static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(String s) {
            try {
                br = new BufferedReader(new FileReader(s));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public FastScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String nextToken() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        public boolean EOF() {
            if (st != null && st.hasMoreTokens()) {
                return false;
            } else {
                String line = null;
                try {
                    line = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (line == null)
                    return true;
                st = new StringTokenizer(line);
                return false;
            }
        }

        int nextInt() {
            return Integer.parseInt(nextToken());
        }

        long nextLong() {
            return Long.parseLong(nextToken());
        }

        double nextDouble() {
            return Double.parseDouble(nextToken());
        }
    }
}

C Necklace

这题我写的比较繁琐。首先找规律可以发现如果出现2个及以上奇数，则无法形成回文。否则，答案是这些数的GCD。构造的时候，可以递归去拼接（拆成gcd段，交替连接当前字符和其他字符）。这个过程比较复杂，详见代码。

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main {
    int n;
    int[] a;
    char[] chars;

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

    StringBuilder Construct(int[] arr, int s) {
        if (s > n) {
            return new StringBuilder("");
        }

        StringBuilder res = new StringBuilder();
        int odd = 0;
        for (int i = s; i <= n; i++) {
            if (arr[i] % 2 == 1) {
                odd++;
                // swap
                int tmp = arr[i];
                arr[i] = arr[s];
                arr[s] = tmp;
                char tmp2 = chars[i];
                chars[i] = chars[s];
                chars[s] = tmp2;
            }
        }
        if (odd > 1 || s == n) {
            for (int i = s; i <= n; i++) {
                for (int j = 1; j <= arr[i]; j++) {
                    res.append(chars[i]);
                }
            }
            return res;
        }

        int GCD = arr[s];

        for (int i = s + 1; i <= n; i++) {

            GCD = gcd(GCD, arr[i]);
        }

        int end = arr[s] / GCD;
        int[] newArr = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            newArr[i] = arr[i] / GCD;
        }

        StringBuilder sbS = new StringBuilder();
        for (int i = 1; i <= end; i++) {
            sbS.append(chars[s]);
        }
        StringBuilder others = Construct(newArr, s + 1);

        String left = others.toString();
        String right = others.reverse().toString();

        if (arr[s] % 2 == 0) {
            res.append(right);
            for (int t = 1; t <= GCD / 2; t++) {
                res.append(sbS);
                res.append(sbS);
                if (t != GCD / 2) {
                    res.append(left);
                    res.append(right);
                } else {
                    res.append(left);
                }

            }
        } else {
            left = left.substring(0, left.length() / 2);
            right = new StringBuilder(left).reverse().toString();
            res.append(right);
            for (int t = 1; t <= GCD; t++) {
                res.append(sbS);
                if (t != GCD) {
                    res.append(left);
                    res.append(right);
                } else {
                    res.append(left);
                }
            }
        }
        return res;
    }

    void Solve() {
        FastScanner scan = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);
        n = scan.nextInt();
        a = new int[n + 1];
        chars = new char[n + 1];
        chars[1] = 'a';
        for (int i = 2; i <= n; i++) {
            chars[i] = (char) (chars[i - 1] + 1);
        }
        int odd = 0;
        for (int i = 1; i <= n; i++) {
            a[i] = scan.nextInt();
            if (a[i] % 2 == 1) {
                odd++;
            }
        }

        int GCD = a[1];
        for (int i = 2; i <= n; i++) {
            GCD = gcd(GCD, a[i]);
        }

        StringBuilder sb = new StringBuilder();
        if (odd > 1) {
            out.println(0);
        } else {
            out.println(GCD);
        }
        sb = Construct(a, 1);
        out.println(sb);
        out.flush();
    }

    public static void main(String[] args) {
        new Main().Solve();
    }

    public static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(String s) {
            try {
                br = new BufferedReader(new FileReader(s));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public FastScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String nextToken() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        public boolean EOF() {
            if (st != null && st.hasMoreTokens()) {
                return false;
            } else {
                String line = null;
                try {
                    line = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (line == null)
                    return true;
                st = new StringTokenizer(line);
                return false;
            }
        }

        int nextInt() {
            return Integer.parseInt(nextToken());
        }

        long nextLong() {
            return Long.parseLong(nextToken());
        }

        double nextDouble() {
            return Double.parseDouble(nextToken());
        }
    }
}
squee_spoon
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
[Codeforces Round #339 (Div. 1)] - C Necklace
LPA的博客
03-14 175
洛谷传送门 Codeforces传送门 题目大意 你有一个n(n≤26)n(n\le 26)n(n≤26)种颜色的珠子， 现在你想要将它们串成手链， 手链的美观度定义为从某个位置切开后， 形成的颜色序列为回文串的方案数。 你要求出最大的可能的美观度。 解题分析 显然我们要构造尽量多的小回文串来构成大的回文串。 如果有两个颜色的珠子数量都为奇数， 显然无解。 如果有一种颜色的珠子数量为奇数， 那么方...
Codeforces Round #849 (Div. 4)
NEFU AB-IN's Blog
02-04 1421
A, B, C, D, E, F, G1
Codeforces Round #770 (Div. 2) ABC题解
weixin_51552756的博客
02-07 316
比赛传送门 题目目录A、Reverse and ConcatenateB、 Fortune TellingC、OKEA A、Reverse and Concatenate 题意：就是给你一个字符串，然后经过k次翻转能得到多少种不同的字符串，他问的其实是一次变化的可能数。 思路：如果这个串是回文串，无论怎么变化都是一种，如果这个串不是回文串，经历过一次变化也会变成回文串 所以答案显然易见： 原串是回文串或者操作为0的情况下：1 否则是：2 int t; read(t); while
【训练】Codeforces Round #877 (Div. 2) ABC题解
想要AC的sjh的博客空间
06-05 264
CF 877(Div.2)部分题解
Codeforces Round #793 (Div. 2)
dfghjkkjjj的博客
05-24 309
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录@[TOC](文章目录) Codeforces Round #793 (Div. 2)前言二、正文A. Palindromic IndicesB. AND Sorting总结 Codeforces Round #793 (Div. 2) 前言 提示：这里可以添加本文要记录的大概内容： Codeforces Round #793 (Div. 2)的ABCD四题 提示：以下是本篇文章正文内容，下面案例可供参考 二、正文 A. Pal.
Codeforces Round #735 (Div. 2)
qq_37978559的博客
07-30 637
Codeforces Round #735 Div. 2A. CherryB. CobbC. Mikasa 很废，做了一题。 第二题应该暴力200的，但只暴力了100 做题地址：Codeforces Round #735 Div.2 A. Cherry 题目： 让连续区间内，最大值和最小值的乘积最大 解决： 可以看出相邻两个的最大乘积就是答案。 分析： 假设最优答案至少是长度为3的连续区间，那么，长度为3的连续区间内，有一个最大值，一个最小值，和一个中等值，那么，相邻两个的乘积要么最大，要么次
Codeforces Round #732 (Div. 2) ABC题解
weixin_51170783的博客
07-12 229
链接：https://codeforces.com/contest/1546 A-AquaMoon and Two Arrays 题意：给你两个数组a[],b[],每次选择两个下标i，j,则a[i]-1，a[j]+1。问你操作多少次使a[]变成b[]，并输出操作过程的i和j的值，如果不存在，则输出-1。 思路：类似于双指针，index1=1，index2=1遍历两个数组，再另外开两个数组存储index1和index2的值。当ans ！= sum 时，输出-1。 代码： #include<bits/st
Codeforces Round #783 (Div. 2)abc
qq_62886369的博客
04-20 248
A - Direction Change 题意： 给定 n 和 m ，就是对于一个 m*n 的矩阵，求从（1，1）到达（n，m）所需要的最小步数，题目限制是，对于上移，下移，左移，右移每个操作不能连续操作。 题解： 我们不难发现，当m和n的绝对值差在1以内的时候，最短步数都是 m+n-2 如图，当m=4时，若n=4，ans=6，若n=5，ans=7，但当n和m的绝对值超过1时，超过一个步数就+3，再超过一个就+1，以此类推，当然还要特判一下n和m等于1的情况 #include <b.
刷题之Codeforces Round #769 (Div. 2)
xxayt的博客
02-02 872
文章目录刷题之Codeforces Round #769 (Div. 2)1632A. ABC1632B. Roof Construction1632C. Strange Test1632D. New Year Concert 刷题之Codeforces Round #769 (Div. 2) 1632A. ABC 题目链接：ABC 题目：判断 01 字符串中是否包含回文子串 思路： ∣s∣≥3|s|\ge 3∣s∣≥3 ：一定不满足 ∣s∣=2|s|=2∣s∣=2：sss 为 000000
Codeforces Round #630 (Div. 2) （ABC）
qq_45833169的博客
11-01 1828
Codeforces Round #630 (Div. 2) A Exercising Walk 水题 题意 就是给你一个起点（x,y），四个数字分别表示左，右，下，上四个方向的移动步数，然后，给你一个范围(x1 <= x <= x2, y1 <=y <= y2)移动过程中必须满足，移动顺序可以任意。 坑点 –菜鸡的自己wa了– 和大多数题的移动方向不一样。 左移动为x-1 右移动为x+1 下移动为y-1 上移动为y+1 #include <cstdio> #inc
Codeforces Round #627 (Div. 3) C. Frog Jumps（思维）
01-20
开始位置在0，问能否跳到n+1位置 每步只能跳d 在1——n每个位置有方向，L,R，求d的最小值 思路： 只用找相邻两个R之间的最大值即可 代码： #include #include #include #include #include #include #include #...
Codeforces Round #627 (Div. 3) B. Yet Another Palindrome Problem
01-03
传送门 题意： 一个长度为n的数组，为删除一些数后，剩下的数能否构成长度大于3的回文数组 思路： 只要能找到两个相等的数，且他们的间距大于2即可 o(n^2)的暴力就能过 比赛时写了一个o(n)的 就是把所有相等的数放到...
Codeforces Round #630 (Div. 2) D. Walk on Matrix（构造）
01-03
上面代码跑出来的dp[n][m]是0，然后从（1，1）（1，2）（2，2）（2，3）这样的相与值是k (看懂ans+k是啥应该就懂了) 代码： int main() { std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0); int ans=(1&...
Codeforces Round #629 (Div. 3) B. K-th Beautiful String
01-03
第一个bbb在倒数第二位有1个字符串，在倒数第三位有2个字符串…在倒数第nnn位时有n−1n-1n−1个字符串 可以根据第一个bbb的位置对字符串进行分组，然后找到第kkk个字符串在第几组里即可，然后再推出第二个bbb的位置...
Codeforces VK Cup 2016 - Round 1 (Div. 2 Edition)
热门推荐
A Cube Master
04-01 1万+
A. Bear and Reverse Radewoosh　　按要求计算一下即可。#include <bits/stdc++.h>#define ll long longusing namespace std;int p[111]; int t[111];int main(){ int n,c; cin>>n>>c; for(int i=1;i<=n;i++){
河南省第七届ACM大学生程序设计竞赛 解题报告
A Cube Master
04-23 3198
这两天把去年省赛的题挂到了OJ上，顺便练手。 A.物资调度 DP，类似01背包。dp(i,j)表示情况数，第一维表示考察到第i种物资，第二维表示总数量为j。显然，如果按照题目给的数据范围，答案会超出64位整型的范围，但是题目并没有要求取模，只能说数据太弱。 B.海岛争霸 Floyd算法，稍微修改一下状态转移方程就可以了。Floyd是求和，这题是取最大。 C.机器人
Google Code Jam 2015 Round 1A 解题报告
A Cube Master
04-18 2231
太弱了，比赛时只出了A的大数据和BC小数据，排到1700+。赛后才把B的小数据过了。 A. Mushroom Monster         就是贪心模拟。第一种吃法，只有当前时刻比10秒前少才去吃减少的量，否则不吃。第二种吃法，计算每十秒的减少量，以减少量最大的作为平均速率去吃。 #include using namespace std; int m[10010];
2015 百度之星初赛1 解题报告
A Cube Master
05-30 1693
1001 超级赛亚ACMer         贪心。首先击败战斗力不大于m的最强者，每次去找可以增强战斗力，然后能击败的最强者，把自己战斗力增加到和他一样去打。如果能打败最强的对手，就可以了。 1002 找连续数         离散化，离线按k从1~1000递增的顺序，维护以每个位置为起点长度为k的最小值，最大值，以及是否有相同数。如果MAX-MIN=k-1且没有相同数，长度为k的
codeforces round #828 (div. 3)
最新发布
06-06
好的，以下是关于Codeforces Round #828 (Div. 3)的一些信息： Codeforces Round #828 (Div. 3)是Codeforces网站上的一场编程竞赛，属于Div. 3级别的比赛。该比赛于2022年3月1日 15:35 (UTC)开始，比赛时长为2个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值