链接：戳这里
so easy
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)
问题描述已知一个包含 nn 个元素的正整数集合 SS，设 f(S)为集合 S 中所有元素的异或(XOR)的结果。
如：S={1,2,3}, 则 f(S) = 0。
给出集合 S，你需要计算 将所有 f(s) 进行异或后的值, 这里s⊆S.
输入描述
多组测试数据。第一行包含一个整数T(T≤20) 表示组数。
每组测试数据第一行包含一个数 n(1≤n≤1,000) 表示集合的大小，第二行为 n 的数表示集合元素。第 i(1≤i≤n) 个数 1000,000,0000≤ai ≤1000,000,000 且数据保证所给集合中没有重复元素。
输出描述
对于每组测试数据，输出一个数，表示将所有的 f(s) 的异或之后的值。
输入样例
1
3
1 2 3
输出样例
0
Hint
样例中，S={1,2,3}, 它的子集有∅, {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}
题意：子集的抑或总和
思路：由于n>1的时候都是偶数出现的 为0
代码：
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
#include<vector>
#include <ctime>
#include<queue>
#include<set>
#include<map>
#include<stack>
#include<cmath>
#define mst(ss,b) memset((ss),(b),sizeof(ss))
#define maxn 0x3f3f3f3f
#define MAX 1000100
///#pragma comment(linker, "/STACK:102400000,102400000")
typedef long long ll;
typedef unsigned long long ull;
#define INF (1ll<<60)-1
using namespace std;
int T;
int n,a[100100];
int main(){
scanf("%d",&T);
while(T--){
scanf("%d",&n);
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
if(n==1) cout<<a[1]<<endl;
else cout<<0<<endl;
}
return 0;
}
xiaoxin juju needs help
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)
问题描述xiaoxin巨从小就喜欢字符串，六年级的时候他就知道了什么是回文串。这时，xiaoxin巨说到：如果一个字符串 SS 是回文串，那么该字符串从前往后看和从后往前看是一样一样的。
六年级的暑假，xiaoxin很快就做完了暑假作业，然后到腾讯做起了实习生。这日，leader给了xiaoxin一个字符串，请xiaoxin帮忙写一个函数来生成所有可能的回文串，可以任意改变字符串的顺序但是不可以扔掉某个字符。并且leader告诉xiaoxin，每生成一个不一样的回文串就可以得到一颗西瓜糖。
请你帮忙计算xiaoxin的leader最多需要买多少颗西瓜糖呢？
输入描述
多组测试数据。第一行包含一个整数 T(T≤20) 表示组数。每组测试数据给出一个只包含小写字母的字符串 S(1≤length(S)≤1,000)
输出描述
对于每组测试数据，输出一个数, 表示leader需要买的西瓜糖的个数，结果对 1,000,000,007 取模。
输入样例
3
aa
aabb
a
输出样例
1
2
1
题意：给出一个字符串,要求该字符串可以组成多少种回文串
思路：回文串左右两边都一样,所以只需要对(n/2)排列组合就可以了,这里取模的话注意有除法,我用的费马小
代码：
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
#include<vector>
#include <ctime>
#include<queue>
#include<set>
#include<map>
#include<stack>
#include<cmath>
#define mst(ss,b) memset((ss),(b),sizeof(ss))
#define maxn 0x3f3f3f3f
#define MAX 1000100
///#pragma comment(linker, "/STACK:102400000,102400000")
typedef long long ll;
typedef unsigned long long ull;
#define INF (1ll<<60)-1
#define mod 1000000007
using namespace std;
ll fac[100100];
ll ppow(ll k,ll n) {
ll c=1;
while(n) {
if(n%2) c=(c*k)%mod;
k=(k*k)%mod;
n>>=1;
}
return c;
}
ll C(ll a,ll b) {
return (((fac[b]*ppow((fac[a]*fac[b-a])%mod,mod-2)))%mod)%mod;
}
int T;
string s;
ll a[30];
int main(){
scanf("%d",&T);
fac[0]=1;
for(int i=1;i<1010;i++) fac[i]=(fac[i-1]*i)%mod;
while(T--){
cin>>s;
mst(a,0);
int n=s.size();
for(int i=0;i<n;i++){
int x=s[i]-'a';
a[x+1]++;
}
int num=0,sum=0;
for(int i=1;i<=26;i++){
if(a[i]%2==0) {
a[i]/=2;
continue;
}
if(a[i]%2==1) {
if(num==0) a[i]/=2;
num++;
}
}
if(num>1) cout<<0<<endl;
else {
ll ans=1;
int L=n/2;
for(int i=1;i<=26;i++){
if(a[i]){
ll tmp=C(a[i],L);
///ll tmp=CCC(L,a[i]);
L-=a[i];
ans*=tmp;
ans%=mod;
}
}
printf("%I64d\n",ans);
}
}
return 0;
}
India and China Origins
Time Limit: 2000/2000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)
问题描述
很久以前，中国和印度之间并没有喜马拉雅山相隔，两国的文化交流很频繁。随着喜马拉雅山海拔逐渐增加，两个地区的交流也越来越少，最终没有了来往。
假设当时的地形和我画的一样，蓝色部分代表海洋，而且当时人们还没有发明轮船。黄色部分代表沙漠，而且沙漠上经常有野鬼散步，所以人们不敢到沙漠中行走。黑色的格子表示山峰，这些山峰都无比高大，所以人无法穿过。白色格子代表平原，人可以在平原上自由行走。人每次可以向相邻的四个格子走动。
此外，我们的考古学家发现还有一些山峰会逐渐形成，通过研究发现，位置在 (x,y) （保证该位置之前没有山峰）的地方在 i 年后出现了山峰。现在给你若干个位置出现山峰的时间，你可以计算出中国和印度之间的联系最早被彻底切断的时间吗？
输入描述
多组测试数据, 第一行为组数T(T≤10)。每组测试数据第一行包含两个数 N,M(1≤N,M≤500), 表示地图的大小。接下来 N 行长度为 M的 01 字符串。0代表白色格子，1 代表山峰。接下来有 Q(1≤Q≤N×M) 行，第 i(1≤i≤Q) 两个整数 (x,y),0≤x<N,0≤y<M 表示在第 i 年 (x,y)出现了一座山峰。
输出描述
对于每组测试数据，输出一个数, 表示两国最早失联的时间。如果最终两国之间还有联系则输出 -1。
输入样例
1
4 6
011010
000010
100001
001000
7
0 3
1 5
1 3
0 0
1 2
2 4
2 1
输出样例
4
Hint
从上图可以看到，两国在第四年彻底失去了联系。
题意：中国和印度需要联通,但是上面有山峰阻挡,山峰随着时间的推移会越来越多,问在哪一个时间两国无法联通
思路：二分时间,然后用并查集去处理0和(n*m+1)是否联通,(1~n*m)是图上的点,显然并查集很好处理连通块的问题
O( n*m*log(n*m) )
代码:
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
#include<vector>
#include <ctime>
#include<queue>
#include<set>
#include<map>
#include<stack>
#include<cmath>
#define mst(ss,b) memset((ss),(b),sizeof(ss))
#define maxn 0x3f3f3f3f
#define MAX 1000100
///#pragma comment(linker, "/STACK:102400000,102400000")
typedef long long ll;
typedef unsigned long long ull;
#define INF (1ll<<60)-1
using namespace std;
int T,n,m,q;
string s[555];
int a[555][555];
int x[555*555],y[555*555];
int xx[4]={-1,0,1,0};
int yy[4]={0,1,0,-1};
int vis[555][555];
int fa[250010];
int find(int x){
if(x!=fa[x])
fa[x]=find(fa[x]);
return fa[x];
}
void Union(int x,int y){
int xx=find(x);
int yy=find(y);
if(xx!=yy) fa[xx]=yy;
}
bool judge(){
mst(vis,0);
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
vis[i][j]=a[i][j];
}
}
for(int i=0;i<=n*m+1;i++) fa[i]=i;
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
if(vis[i][j]) continue;
for(int k=0;k<4;k++){
int X=i+xx[k];
int Y=j+yy[k];
if(Y<1 || Y>m) continue;
if(vis[X][Y]) continue;
if(X==0) Union(0,(i-1)*m+j);
else if(X==n+1) Union(n*m+1,(i-1)*m+j);
else {
Union((i-1)*m+j,(X-1)*m+Y);
}
}
}
}
if(find(0)==find(n*m+1)) return true;
return false;
}
bool solve(int k){
for(int i=1;i<=k;i++) a[x[i]][y[i]]=1;
int t=0;
if(judge()) t=1;
for(int i=1;i<=k;i++) a[x[i]][y[i]]=0;
if(t) return true;
return false;
}
int main(){
scanf("%d",&T);
while(T--){
scanf("%d%d",&n,&m);
mst(a,0);
for(int i=0;i<n;i++) cin>>s[i];
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
if(s[i][j]=='1') a[i+1][j+1]=1;
else a[i+1][j+1]=0;
}
}
scanf("%d",&q);
for(int i=1;i<=q;i++){
scanf("%d%d",&x[i],&y[i]);
x[i]++;
y[i]++;
}
if(solve(q)){
cout<<-1<<endl;
continue;
}
int l=1,r=q,mid,ans=0;
while(l<r){
mid=(l+r)/2;
if(solve(mid)) l=mid+1;
else r=mid,ans=mid;
}
cout<<ans<<endl;
}
return 0;
}
Bomber Man wants to bomb an Array.
Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)
问题描述
给一个长度为 N 的一维格子和一些炸弹的位置，请你计算 “最大总破坏指数”。
每个炸弹都有向左和向右的破坏力，如果一个炸弹向左和向右的破坏力分别为 L 和 R,
那么该炸弹将炸毁L+R+1 个格子（左边L个，炸弹所在格子，右边R个）。
破坏指数的计算方式为：所有炸弹炸毁的格子数的乘积。假设第 ii 个炸弹炸毁了 Xi个格子，
那么总破坏指数就是 X1 ∗X2 ∗....Xm。
现在告诉你每个炸弹的位置，你需要计算 最大的总破坏指数，注意：每个格子最多只允许被炸一次。
输入描述
多组测试数据，第一行为一个整数 T(T≤11)。
每组测试数据第一行为两个整数 N,M(1≤N≤2000,1≤M≤N)，分别表示格子总数和炸弹总数 。
第二行是 M个互不相同的数表示每个炸弹所在的位置。
输出描述
对于每组测试数据，输出 floor(10^6 * log2(最大破坏指数)) (floor表示向下取整)。
输入样例
2
10 2
0 9
10 3
0 4 8
输出样例
4643856
5169925
Hint
Sample 1 :
Sample 2:
题意：给出一维长度n,格子上有m个炸弹,要求自己设定炸弹的l,r使所有炸弹爆炸的总乘积最大
思路：看了卿神的思路,哎,赤裸裸的暴力,感觉复杂度就是O(n*m) 常数大一点好像
dp[i][j] 表示第i个炸弹炸到j格子的当前最大总乘积
dp[i][j]=max(dp[i][j],(j-k)*dp[i-1][k]) 枚举每i-1个炸弹能炸的长度,其实也就是区间[ a[i-2]+1~a[i-1], a[i-1]+1~a[i] ]
这里加一个炸弹m+1 放在n+2 就是方便计算第m个炸弹炸到n+1之前的最大值
代码：
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
#include<vector>
#include <ctime>
#include<queue>
#include<set>
#include<map>
#include<stack>
#include<iomanip>
#include<cmath>
#define mst(ss,b) memset((ss),(b),sizeof(ss))
#define maxn 0x3f3f3f3f
#define MAX 1000100
///#pragma comment(linker, "/STACK:102400000,102400000")
typedef long long ll;
typedef unsigned long long ull;
#define INF (1ll<<60)-1
using namespace std;
long double dp[2001][2001];
int n,m;
int a[2001];
int main(){
int T;
scanf("%d",&T);
while(T--){
mst(dp,0);
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++) {
scanf("%d",&a[i]);
a[i]++;
}
sort(a+1,a+m+1);
for(int i=1;i<=a[1];i++) dp[1][i]=1.0;
a[++m]=n+2;
for(int i=2;i<=m;i++){
for(int j=a[i-1]+1;j<=a[i];j++){
for(int k=a[i-2]+1;k<=a[i-1];k++){
dp[i][j]=max(dp[i][j],(j-k)*dp[i-1][k]);
}
}
}
long double ans=floor(1000000.0*log2(dp[m][n+1]));
///cout<<setprecision(0)<<ans<<endl;
printf("%.0lf\n",ans);
}
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
