Codeforces 903 绝对值1e19longdouble算贡献 汉明距离交换两项是否可行

最新推荐文章于 2024-11-04 22:26:34 发布
最新推荐文章于 2024-11-04 22:26:34 发布
阅读量114 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/Aragaki/p/9118823.html
版权

A

/*Huyyt*/
#include<bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
#define pb push_back
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int dir[8][2] = {{0, 1}, {1, 0}, {0, -1}, { -1, 0}, {1, 1}, {1, -1}, { -1, -1}, { -1, 1}};
const int mod = 1e9 + 7;
const int gakki = 5 + 2 + 1 + 19880611 + 1e9;
const int N = (1 << 22) + 5;
int main()
{
        int T;
        cin >> T;
        while (T--)
        {
                int flag=0;
                int n;
                cin >> n;
                for (int i = 0; i <= n / 3; i++)
                {
                        if ((n - 3 * i) % 7 == 0)
                        {
                                cout << "YES" << endl;
                                flag=1;
                                break;
                        }
                }
                if(!flag)
                {
                        cout<<"NO"<<endl;
                }
        }

        return 0;
}
View Code

B

 /*Huyyt*/
#include<bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
#define pb push_back
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int dir[8][2] = {{0, 1}, {1, 0}, {0, -1}, { -1, 0}, {1, 1}, {1, -1}, { -1, -1}, { -1, 1}};
const int mod = 1e9 + 7;
const int gakki = 5 + 2 + 1 + 19880611 + 1e9;
const int N = (1 << 22) + 5;
string ans[100005];
int cnt = 0;
int main()
{
        ios_base::sync_with_stdio(0);
        cin.tie(0);
        int h1, a1, c1;
        int h2, a2;
        cin >> h1 >> a1 >> c1;
        cin >> h2 >> a2;
        while (h2 > 0)
        {
                if (h2 - a1 <= 0)
                {
                        ans[++cnt] = "STRIKE";
                        h2 -= a1;
                        continue;
                }
                if (h1 - a2 <= 0)
                {
                        ans[++cnt] = "HEAL";
                        h1 += c1-a2;
                        continue;
                }
                ans[++cnt] = "STRIKE";
                h1 -= a2;
                h2 -= a1;
        }
        cout << cnt << endl;
        for (int i = 1; i <= cnt; i++)
        {
                cout << ans[i] << endl;
        }
        return 0;
}
View Code

C

/*Huyyt*/
#include<bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
#define pb push_back
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int dir[8][2] = {{0, 1}, {1, 0}, {0, -1}, { -1, 0}, {1, 1}, {1, -1}, { -1, -1}, { -1, 1}};
const int mod = 1e9 + 7;
const int gakki = 5 + 2 + 1 + 19880611 + 1e9;
const int N = 5e3 + 5;
int vis[N];
int num[N];
int visit[N];
int main()
{
        ios_base::sync_with_stdio(0);
        cin.tie(0);
        int n;
        cin >> n;
        int maxn = -1;
        for (int i = 1; i <= n; i++)
        {
                cin >> num[i];
                maxn = max(maxn, num[i]);
        }
        sort(num + 1, num + 1 + n);
        for (int i = 1; i <= n; i++)
        {
                if (visit[i])
                {
                        continue;
                }
                int cur = num[i];
                int pre = i;
                vis[pre] = 1;
                visit[pre] = 1;
                for (int j = i + 1; j <= n; j++)
                {
                        if (num[j] > cur && !visit[j])
                        {
                                visit[j] = 1;
                                vis[pre] = 0;
                                cur = num[j];
                                pre = j;
                                vis[pre] = 1;
                        }
                }
        }
        int anser = 0;
        for (int i = 1; i <= n; i++)
        {
                if (vis[i])
                {
                        anser++;
                }
        }
        cout << anser << endl;
        return 0;
}
View Code

D

会爆long long 要用long double

/*Huyyt*/
#include<bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
#define pb push_back
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int dir[8][2] = {{0, 1}, {1, 0}, {0, -1}, { -1, 0}, {1, 1}, {1, -1}, { -1, -1}, { -1, 1}};
const int mod = 1e9 + 7;
const int gakki = 5 + 2 + 1 + 19880611 + 1e9;
const int N = 2e5 + 5;
map<double, double> mp;
long double num[N];
long double now;
long double sheng;
int main()
{
        ios_base::sync_with_stdio(0);
        cin.tie(0);
        long double sum = 0;
        long double anser = 0;
        int n;
        cin >> n;
        for (int i = 1; i <= n; i++)
        {
                cin >> num[i];
                sum += num[i];
                mp[num[i]]++;
        }
        for (int i = 1; i < n; i++)
        {
                sum -= num[i - 1];
                if (i != 1)
                {
                        mp[num[i - 1]]--;
                }
                sheng = n - i + 1 - mp[num[i] - 1] - mp[num[i] + 1];
                anser += sum - mp[num[i] - 1] * (num[i] - 1) - mp[num[i] + 1] * (num[i] + 1) - sheng * num[i];
        }
        cout << fixed << setprecision(0) << anser << endl;
        return 0;
}
View Code

 JAVA版

import java.io.OutputStream;
import java.io.PrintWriter;

import java.math.BigInteger;
import java.util.*;;


public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        OutputStream outputStream = System.out;
        PrintWriter out = new PrintWriter(outputStream);

        SortedMap<Long, Long>ma  = new TreeMap<>() ;
        BigInteger result = new BigInteger("0");
        BigInteger currentSum  = new BigInteger ("0");


        int n = in.nextInt();
        for (int i = 0; i < n; i++) {
            long x = in.nextInt();

            long count = i - (ma.getOrDefault(x - 1,0L) + ma.getOrDefault(x,0L) + ma.getOrDefault(x + 1,0L));
            long toRemove = (x - 1) * ma.getOrDefault(x - 1,0L) + (x)* ma.getOrDefault(x,0L) + (x + 1) * ma.getOrDefault(x + 1,0L);
            BigInteger valueY = currentSum.subtract(new BigInteger(String.valueOf(toRemove)));

            result = result.add(new BigInteger(String.valueOf((x * count)))).subtract(valueY);

            currentSum = currentSum.add(new BigInteger(String.valueOf(x)));
            ma.put(x, ma.getOrDefault(x,0L)+1);
        }

        out.println(result.toString());

        in.close();
        out.close();
    }
}
View Code

E

题意:

给你K个长度为N的字符串 每个字符串可以交换任意两项一次 问你这N个字符串能不能最后都变为一个字符串

解:

以第一个字符串为主串 N枚举每个其他串 测出与其他串的汉明距离

然后K2枚举交换的位置 再N枚举其他串 看交换后是否满足

满足有两种情况 1.第一个字符串有两个相同字母 交换后的汉明距离为0   2.交换后的汉明距离为2

当当前交换的两项可以满足所有其他串时 交换这两项后的字符串就是目标串

/*Huyyt*/
#include<bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int dir[8][2] = {{0, 1}, {1, 0}, {0, -1}, { -1, 0}, {1, 1}, {1, -1}, { -1, -1}, { -1, 1}};
const int mod = 1e9 + 7, gakki = 5 + 2 + 1 + 19880611 + 1e9;
const int MAXN = 1e5 + 5, MAXM = 1e5 + 5, N = 1e4 + 5;
const int MAXQ = 100010;
int to[MAXM << 1], nxt[MAXM << 1], Head[MAXN], tot = 1;
inline void addedge(int u, int v)
{
        to[++tot] = v;
        nxt[tot] = Head[u];
        Head[u] = tot;
}
inline void read(int &v)
{
        v = 0;
        char c = 0;
        int p = 1;
        while (c < '0' || c > '9')
        {
                if (c == '-')
                {
                        p = -1;
                }
                c = getchar();
        }
        while (c >= '0' && c <= '9')
        {
                v = (v << 3) + (v << 1) + c - '0';
                c = getchar();
        }
        v *= p;
}
string st[3005];
int num[2][30];
int hmdis[3000];
int n, k;
int flag = 0;
int main()
{
        ios_base::sync_with_stdio(0);
        cin.tie(0);
        cin >> k >> n;
        for (int i = 1; i <= k; i++)
        {
                cin >> st[i];
        }
        for (int i = 0; i < n; i++)
        {
                num[0][st[1][i] - 'a']++;
                if (num[0][st[1][i] - 'a'] > 1)
                {
                        flag = 1;
                }
        }
        for (int i = 2; i <= k; i++)
        {
                mem(num[1], 0);
                for (int j = 0; j < n; j++)
                {
                        num[1][st[i][j] - 'a']++;
                        if (st[1][j] != st[i][j])
                        {
                                hmdis[i]++;
                        }
                }
                for (int j = 0; j <= 25; j++)
                {
                        if (num[1][j] != num[0][j])
                        {
                                cout << -1 << endl;
                                return 0;
                        }
                }
        }
        for (int i = 0; i < n - 1; i++)
        {
                for (int j = i + 1; j < n; j++)
                {
                        int now = 0;
                        for (int w = 1; w <= k; w++)
                        {
                                int cnt = hmdis[w];
                                if (st[1][i] == st[w][i])
                                {
                                        cnt++;
                                }
                                if (st[1][j] == st[w][j])
                                {
                                        cnt++;
                                }
                                if (st[1][i] == st[w][j])
                                {
                                        cnt--;
                                }
                                if (st[1][j] == st[w][i])
                                {
                                        cnt--;
                                }
                                if (cnt == 2 || (cnt == 0 && flag))
                                {
                                        now++;
                                }
                                else
                                {
                                        break;
                                }
                        }
                        if (now == k)
                        {
                                swap(st[1][i], st[1][j]);
                                cout << st[1] << endl;
                                return 0;
                        }
                }
        }
        cout << -1 << endl;
        return 0;
}
View Code

 

转载于:https://www.cnblogs.com/Aragaki/p/9118823.html

baichuan9723
关注
解题报告（十八）数论题目泛做（Codeforces 难度：2000 ~ 3000 + ）
繁凡さん的博客
06-14 4028
解题报告（十八）Codeforces - 数学题目泛做（难度：2000 ~ 3000 + ）
CodeForces598C long double与atan2()
OtterVのrecorder
07-29 277
C. Nearest vectors time limit per test 2 seconds memory limit per test 256 megabytes input standard input output standard output You are given the set of vectors on the plane, each of them st...
Codeforces621D 高精度 long double + 取log
枚举星星
02-27 308
这题。。。一言难尽 意思是给你 x y z 让你求十二种形式哪个最大 x的y次幂的z次幂啊balabala各种组合 自己刚开始wa到第五组也不知道咋回事 后来发现是最后一组写错了 数据范围0.1~200.0 而且我是取了两次log 网上说精度会有损失 所以long double+一次log是最稳妥的 下面放一下各种浮点数范围 float 32bit -3.410 ^ 38 ～+3.410...
codeforces 903D Almost Difference
weixin_45632274的博客
05-24 166
CF903D Almost Difference 题目描述 让我们来表示一个函数 给您一个数组,一个由n整数组成的数组.你必须计算所有对（i,j）的d值（a[i]，a[j]），比如1<=i<=j<=n。(差绝对值为1值为0，大于1为a[j]-a[i]) 输入数据 第一行包含一个整数n（1<=n<=200000）——a中的元素数。 第二行包含n整数a[1]、a[2]、…、a[n]（1<=a[i]<=10^9）——数组的元素。 输出数据 在所有对（i,j）中打印一个整
codeforces 903D
weixin_30412013的博客
12-14 85
D. Almost Difference time limit per test 2 seconds memory limit per test 256 megabytes input standard input output standard output Let's denote a function You are given an ar...
Codeforces Global Round 19(A-D）
eyuhaobanga的博客
02-13 510
Problem - A - Codeforces 签到题，判断输入的数列是否已经排好序 AC代码： /* Tips: 1.int? long long? 2.don't submit wrong answer 3.figure out logic first, then start writing please 4.know about the range 5.check if you have to input t or not 6.modulo of n...
Codeforces 491B. New York Hotel 【枚举】【曼哈顿距离】
Kadimarx的博客
02-14 466
DescriptionThink of New York as a rectangular grid consisting of N vertical avenues numerated from 1 to N and M horizontal streets numerated 1 to M. C friends are staying at C hotels located at some st
Codeforces Round 981 div3 个人题解(A~G)
Lazy_ChessPlayer的博客
10-25 1552
Codeforces Round 981 div3 个人题解(A~G)
CodeForces:54
BUG_Creater_jie的博客
12-20 684
一场很水的远古比赛
Codeforces Round #644 (Div. 3)
qq_43461168的博客
01-12 222
A. Minimal Square 题意：两个相等的矩形，长宽为a，b求一个最小的正方形，能够不重叠地放下这两个矩形。 思路：要么都横着放，要么都竖着放，要么一横一竖。取最小。 AC代码： #include <bits/stdc++.h> #define int long long #define mk make_pair #define PII pair<int,int> const int N = 1e6+10; const int mod = 1e9+7; using name
CodeForces601D【单调栈维护最大值】
ONE MORE TRY
11-29 720
思路： 区间最值一定是相邻的差值的绝对值。预处理差值绝对值，预处理以每个位置的值为最大值能延伸的最长距离（单调栈处理）。 然后每次询问就是枚举区间，计算每个值的贡献。//#pragma comment(linker, "/STACK:102400000,102400000") #include <stdio.h> #include <string.h> #include <iostream> #
Educational Codeforces Round 126 (Rated for Div. 2)
m0_51731088的博客
04-29 149
A. Array Balancing 题意：给出a和b两个数组，可以对相同位置上的a和b进行交换，求a和b数组中所有相邻两个数的绝对值之和的最小值。 思路：使较小的在一边，较大的在一边。 #include<bits/stdc++.h> using namespace std; typedef long long ll; const int N = 30; int a[N],b[N]; int main() { int t; cin>>t; while(t--) { int
Codeforces Round #640 (Div. 4) 全部题解
weixin_45590210的博客
05-10 579
比赛 难得一见div4的场.也是第一次体会到了AK的快乐(虽然打的是virtual).难度应该在div2的ABC吧.码风以暴力为主. A - Sum of Round Numbers 题目大题:给一个数,把每一位拆出来. 比如5423拆成 5000 400 20 3 就拆就完事了… 代码 #pragma GCC optimize(3) #define LL long long #define pq priority_queue #define ULL unsigned long long #define p
【Codeforces 578 C. Weakness and Poorness】三分+最大子段和
我是谁 --- 卡比兽
07-14 293
cf578C • 给定一个序列A • 一个区间的poorness定义为这个区间内和的绝对值 • weakness等于所有区间最大的poorness • 求一个x使得，序列A全部减x后weakness最小 • 1 ≤ n ≤ 2 * 1e5 做法 首先对样例发现随着x增加 答案会增加 x减少 答案会减少 那么这是一个谷函数 可以三分 最大子段和就用最大子段和的算法算 但是绝对值 只要把数组相反数再求...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 637
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 1125
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
spring循环依赖解决方式
qq_36400213的博客
11-04 781
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 464
默认对常规Session的理解和使用，如何使用Set-Cookie。
【Java知识】Java基础-对象排序的实现
最新发布
wendao76的专栏
11-04 259
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
Codeforces集训队作业：两题解法与GreedyChange挑战
在本次集训队作业中，参与者展示了在Codeforces平台上解决的两个问题：TwoFriends和Beads，以及一个额外的题目 GreedyChange。这些问题涉及了不同的算法策略和技巧。 1. TwoFriends： 这是一道关于几何与优化的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值