由于格式问题
题面还是去跳转吧: 传送门
Time limit per test: 1.0 seconds
Memory limit: 512 megabytes
几乎每个学 C 语言的人都会面临这样一种困惑：为什么 % 只支持整数和整数，不支持浮点数。自然，C++ 提供了运算符重载几乎可以很方便地实现自定义的浮点数模运算，但到底是不方便的。
而与此相对比的，Java / Python 等高级语言就直接支持了浮点数模运算。
本题就是：给两个浮点数 a, b，求 amodb。
然后你会发现，事情并不简单。
Input
一行两个浮点数 a, b (0<a,b≤109)，a, b 保证保留到小数点后第九位。
Output
输出浮点数，相对误差或绝对误差不超过 10−15。
假设你的答案是 a，标准答案是 b，你的答案正确当且仅当 |a−b|max(1,|b|)<10−15。
Examples
3.000000000 2.000000000
1.000000000
0.400000000 0.200000000
0
题解：
1. C : 将浮点转换为高精度整数，模拟取余
2. Java 高精度
代码:
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;
import java.io.*;
public class Main {
public static void main(String args[])
{
BigDecimal a,b;
Scanner cin = new Scanner(System.in);
while(cin.hasNext())
{
a = cin.nextBigDecimal();
b = cin.nextBigDecimal();
BigDecimal ans = a.remainder(b);
//ans.setScale(9,BigDecimal.ROUND_HALF_UP);
System.out.println(ans);
}
}
}Time limit per test: 2.0 seconds
Memory limit: 512 megabytes
kblack 在做数螃蟹的实验。按照「螃蟹爷爷的秘诀」一书上介绍的：由于东方神秘力量的影响，螃蟹的个数是一个完美的等差数列，例如：−2,−1,0,1,2,…。是的，kblack 的螃蟹比较神奇，有的时候螃蟹的个数可能会是负的。
kblack 每天都去池塘记录螃蟹的个数。但是 kblack 自己给自己放了最多三天的假（也有可能两天，有可能一天，有可能不放），放假的时候螃蟹个数的记录就是 kblack 口胡的，有的时候会假得有点过分。
现给出 kblack n 天的记录，记录中至多有三个数是错误的。请纠正错误并输出正确的实验记录。
Input
第一行是一个整数 n (3≤n≤105)。
第二行给出 n 个整数：a1,a2,…,an (|ai|≤109)。
Output
输出正确的实验记录：n 个整数 b1,b2,…,bn。输出应是一个等差数列，与输入的数列至多有三个数不同，且保证 |bi|≤1018。
题目保证有解。如果有多解输出任意一解。
Examples
5 1 2 4 4 5
1 2 3 4 5
4 1 3 5 7
1 3 5 7
4 2 3 3 3
4 3 2 1
题解：
只需要做个差分，则等差值一定是差分数组中出现最多的。
证明：无？？随机也能过。
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e5+10;
ll arr[maxn],cha[maxn],ans[maxn];
map<ll,int> ma;
map<ll,int>::iterator it;
int n;
bool judge(int pos,ll d) {
ans[pos] = arr[pos];
int cnt = 0;
for(int i=pos-1;i>=1;i--) {
ans[i] = ans[i+1] - d;
if(ans[i] != arr[i]) cnt++;
}
for(int i=pos+1;i<=n;i++) {
ans[i] = ans[i-1] + d;
if(ans[i] != arr[i]) cnt++;
}
return cnt <= 3;
}
void print() {
for(int i=1;i<n;i++) printf("%lld ",ans[i]);
printf("%lld\n",ans[n]);
}
int main()
{
scanf("%d",&n);
{
for(int i=1;i<=n;i++) scanf("%lld",&arr[i]);
for(int i=2;i<=n;i++) cha[i] = arr[i] - arr[i-1];
ma.clear();
for(int i=2;i<=n;i++) ma[cha[i]]++;
ll Maxnum = -1;
for(it = ma.begin();it != ma.end();it++) {
if(Maxnum == -1 || it->second > ma[Maxnum]) Maxnum = it->first;
}
ll d = Maxnum;
for(int i=2;i<=n;i++) if(cha[i] == d) {
if(judge(i,d)) {
print();
break;
}
}
}
return 0;
}
Time limit per test: 3.0 seconds
Memory limit: 1024 megabytes
在面向对象程序设计中，常常会运用到函数的扩展与重写。当一个类继承某个类的时候，它可以调用所有父类可以调用的函数。它可以声明新的函数。当新的函数签名与父类的某个函数一致时，就会发生函数的覆盖（重写）。所以，在子类的实例调用某个函数时，它会调用最近的父类（有可能是它自己）的那个函数实现。
这里我们不考虑访问权限等情况，我们只关心某个类在调用某个函数时，这个函数是在哪个类中实现的。
Input
输入具有如下格式：
np2 p3 … pnt1 a11 a12 … a1t1t2 a21 a22 … a2t2⋮tn an1 an2 … antnqu1 r1u2 r2⋮uq rq
解释与数据规模约定：
- n 表示有 n 个类，这些类从 1 到 n 编号。2≤n≤105。
- pi 表示第 i 个类的父类编号。1≤pi≤i−1。第 1 个类是所有类共同的祖先类，这个类没有父类。
- ti 表示在第 i 个类中定义了多少个函数，ai1,ai2,…,aiti 表示第 i 个类中的函数列表。同一个类的函数列表中不会出现两个相同的函数。1≤aij≤106。0≤ti≤106,∑ti≤106。
- q 表示询问个数。1≤q≤105。
- ui,ri 表示第 i 个询问，询问第 ui 个类的实例在调用 ri 函数时，调用的是哪个类中的版本。1≤ui≤n,1≤ri≤106。
Output
对于每个询问，输出答案。如果调用不合法（会导致编译错误），输出 −1。
Examples
5 1 2 3 3 2 2 1 0 2 5 2 2 4 5 1 5 4 3 4 5 2 4 5 1 3
-1 3 4 -1
Note
样例等价于下面的 Java 代码。
class Class1 { void function2() { System.out.println("1"); } void function1() { System.out.println("1"); } } class Class2 extends Class1 { } class Class3 extends Class2 { void function5() { System.out.println("3"); } void function2() { System.out.println("3"); } } class Class4 extends Class3 { void function4() { System.out.println("4"); } void function5() { System.out.println("4"); } } class Class5 extends Class3 { void function5() { System.out.println("5"); } } void test() { new Class3().function4(); new Class5().function2(); new Class4().function5(); new Class1().function3(); }
首先是题意，给了一个有n个节点的树，保证根节点为1,每一个节点可能控制着若干函数，最后有q组询问，每组询问查询当前节点a的第b个函数被哪个节点控制，查询不合法就输出-1.
我们用邻接表先把这个树和每一个查询存起来，然后用一遍dfs，在遍历整个树的时候先查看当前节点控制着哪些函数，然后添加在对应的栈中去，然后查看当前节点是否有询问，如果有的时候就去栈中找答案。然后继续dfs，在回溯的时候进行出栈操作吗，整个过程是离线的，只需要对一棵树进行一遍dfs即可
代码:
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e5+10;
struct node {
int funs,id;
};
vector<struct node> query[maxn];
vector<int> Store[maxn],way[maxn];
stack<int> Fun[maxn*10];
int arr[maxn],ans[maxn];
void dfs(int rt)
{
for(auto v:Store[rt])
Fun[v].push(rt);
for(auto v:query[rt]) {
if(Fun[v.funs].empty()) ans[v.id] = -1;
else ans[v.id] = Fun[v.funs].top();
}
for(auto v:way[rt]) dfs(v);
for(auto v:Store[rt]) Fun[v].pop();
}
inline void init()
{
for(int i=0;i<maxn;i++) {
way[i].clear();Store[i].clear();query[i].clear();
while(!Fun[i].empty()) Fun[i].pop();
}
}
int main()
{
int n;
while(~scanf("%d",&n))
{
init();
for(int i=2,x;i<=n;i++) {
scanf("%d",&x);
way[x].push_back(i);
}
for(int i=1,x,y;i<=n;i++) {
scanf("%d",&x);
while(x--) {
scanf("%d",&y);
Store[i].push_back(y);
}
}
int q,u;
node temp ;
scanf("%d",&q);
for(int i=1;i<=q;i++) {
scanf("%d%d",&u,&temp.funs);
temp.id = i;
query[u].push_back(temp);
}
dfs(1);
for(int i=1;i<=q;i++) printf("%d\n",ans[i]);
}
return 0;
}
Time limit per test: 1.0 seconds
Memory limit: 512 megabytes
这是一个无聊的数学题。
非形式化地说：从 0,1,…,2n−1 中选出若干个数，使得这些数的异或和为 k。求有多少种方案？
形式化地说：现给出 n,p,k，输出 {0,1,…,2n−1} 有多少个非空子集异或和恰好为 k。输出结果模 p 的值。
Input
一行三个整数 n, k, p (1≤n≤1018, 0≤k≤min(2n−1,1018), 2≤p≤109, p 是质数)。
Examples
2 3 998244353
4
Note
样例解释：k=3，有以下四个方案：{1,2}, {3}, {0,3}, {0,1,2}。
在数字逻辑中，异或是对两个运算元的一种逻辑分析类型，符号为 XOR 或 ⊕。与一般的逻辑或 OR 不同，当两两数值相同为否，而数值不同时为真。对于任意两个数的异或：先写出这两个数的二进制表示，然后对于每一位进行异或。在 C 语言中写作 a ^ b。
题解：
当 p 不等于 2 时，我们可以想到的是
这里给出指数节公式
根据公式
综上
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll n,k,p;
ll mut(ll a,ll b,ll mod)
{
ll ans = 0;
while(b) {
if(b & 1) ans = (ans + a) % mod;
a = (a + a) % mod;
b >>= 1;
}
return ans;
}
ll power(ll a,ll b,ll mod)
{
a %= mod;
ll ans = 1;
while(b) {
if(b & 1) ans = mut(ans,a,mod);
a = mut(a,a,mod);
b >>= 1;
}
return ans;
}
ll phi(ll n)
{
ll ans = n;
for(ll i = 2;i*i<=n;i++)
{
if(n % i == 0) {
ans = ans - ans / i;
while(n % i == 0) n /= i;
}
}
if(n > 1) ans = ans - ans / n;
return ans;
}
ll inv(ll a,ll mod)
{
return power(a,mod-2,mod)%mod;
}
int main()
{
while(~scanf("%lld%lld%lld",&n,&k,&p))
{
ll ans = 0;
if(p != 2)
{
ll phip = phi(p);
ll a = power(2,n,phip) + phip;
a = power(2,a,p);
ll b = power(2,n,p);
ans = a * inv(b,p) % p;
if(!k) ans--;
ans = (ans % p + p) % p;
}
else
{
ans = 0;
if(!k) ans = 1;
}
printf("%lld\n",ans);
}
return 0;
}
366
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
