F: 是你飘了，还是我拿不动刀了
时间限制: 1 Sec 内存限制: 128 MB提交: 910 解决: 157
Eternally给出长度在1000以内的英语文章，让你找出文章中的单词，按照英语的格式是每个单词是以空格分开的，但是呢，在这里不同，每个单词是以除大小写字母以外的字符来分开的。
例如Eternally#is#a#student中Eternally,is,a,student是单词。
(不必多想，Eternally输入的文章中的每个单词有可能在英语中不是单词)。
输入包含多组输入，每行是一篇文章（文章，是没有空格的）。
输出有特定的格式，输出单词时请按照单词在文章中的顺序输出单词。（如果同一个单词有多个,那么就只输出最先出现的那个），如果是Eternally开玩笑给的文章中没单词，那么输出NO.
Eternally@is@a@student
Case 1:
Eternally
is
a
student
代码：
import java.util.List;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.Iterator;
public class Main {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
String str,temp;
int i,cas=0;
boolean f,haveletter;
List<String> list=new ArrayList<String>();
while(input.hasNext())
{
list.clear();
str=input.nextLine();
str+="#"; //最后加上一个非字母字符为了使所有字母都入List
int len=str.length();
haveletter=f=false;
temp="";
++cas;
System.out.println("Case "+cas+":");
for(i=0;i<len;i++)
{
if(Character.isLetter(str.charAt(i))) //当前字符是字母，加入当前字符串中
{
temp+=str.charAt(i);
haveletter=f=true; //haveletter是说整个字符串中有字母所以有单词不用输出NO，f是说明这里出现了字母，用来形成当前字符串用
}else { //如果当前字符不是字母
if(f) //如果前一个是字母，说明刚好一个单词已经结束，保存下来
{
if(list.indexOf(temp)==-1) //此单词未出现过才保存
{
list.add(temp);
}
}
f=false;
temp="";
}
}
if(haveletter==false)
System.out.println("NO");
else {
Iterator<String> it=list.iterator();
while(it.hasNext())
{
String s=it.next();
System.out.println(s);
}
}
}
input.close();
}
}
G: 三角填阵
提交: 666 解决: 173
请用+-*/这四个符号依次填入以N为高的等腰三角阵中，以N为5的三角阵为例，填入顺序如图所示。
先输入一个T表示测试组数，之后输入T个等腰三角阵的高N，其中0<=T<10,0<=n<50。
请为每组测试给出一个三角阵，每组间用一个空行隔开。
1
10
+
* -
/ - *
- + + /
* + - / +
+ / / * * -
- / + * / - *
/ * * - - + + /
+ * / - * + - / +
* - - + + / / * * -
代码：
#include<iostream>
#include<string>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<queue>
#include<cstring>
#include<map>
using namespace std;
typedef long long ll;
int n;
char ch[4]={'+','-','*','/'};
char m[55][55];
void init()
{
int i,j;
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
m[i][j]=' ';
}
void dfs(int i,int j,int f,int it) //i,j是当前要赋值的块，f判断方向，it判断用到那个字符
{
if(it==4)
it=0;
m[i][j]=ch[it];
//cout<<i<<" "<<j<<" "<<m[i][j]<<endl;
if(i==n&&j==1)
return;
if(j==1) //如果排到最左边
{
if(f==0) //如果是向上排的，该往下拐了
dfs(i+1,j,1,it+1);
else //如果往下排的，说明已经拐弯了
dfs(i+1,j+1,1,it+1);
}else if(i==n){ //如果排到最下一行
if(f==1) //如果是往下排，该往上拐弯了
dfs(i,j-1,0,it+1);
else
dfs(i-1,j-1,0,it+1);
}else{
if(f==1)
dfs(i+1,j+1,f,it+1);
else
dfs(i-1,j-1,f,it+1);
}
}
int main()
{
int T,i,j;
scanf("%d",&T);
while(T--){
scanf("%d",&n);
if(n==0)
continue;
init();
dfs(1,1,1,0); //1是向下,0是向上
for(i=1;i<=n;i++)
{
for(j=1;j<i;j++)
cout<<m[i][j]<<' ';
cout<<m[i][j]<<endl;
}
cout<<endl;
}
return 0;
}
问题 H: 周老师的区间问题
时间限制: 1 Sec 内存限制: 128 MB提交: 1014 解决: 128
周老师无聊时乱写了 n 个区间，但处女座的他随后又想将 n 个区间整理合并，但他发现区间太多了，于是他想请你帮帮他
每次测试输入多组数据（小于100组），对于每组输入数据:
第一行为 n ，代表 n 个区间
接下来 n 行，每行两个数 s , t 代表区间 [s,t]
0 < n < 15000
0 <= s <= t < 10000000
第一行输出一个数字 q ，代表合并后剩余的区间个数
随后 q 行 按从小到大的顺序输出区间
3
2 4
1 3
7 7
2
1 4
7 7
代码：
#include<iostream>
#include<string>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<queue>
#include<cstring>
#include<map>
using namespace std;
typedef long long ll;
#define M 15005
ll n;
struct node {
ll s,t;
bool operator <(const node & obj)const
{
return s<obj.s||(s==obj.s&&t<obj.t);
}
}section[M];
int main()
{
int i;
while(cin>>n){
for(i=0;i<n;i++)
cin>>section[i].s>>section[i].t;
sort(section,section+n);
int num=0;
//t=section[0].t;
for(i=1;i<n;i++)
{
if(section[i].s<=section[num].t&§ion[num].t<section[i].t) {
section[num].t=section[i].t;
}else if(section[i].s>section[num].t) {
num++;
section[num].s=section[i].s;
section[num].t=section[i].t;
}
}
cout<<num+1<<endl;
//sort(ans,ans+num);
for(i=0;i<=num;i++)
{
cout<<section[i].s<<" "<<section[i].t<<endl;
}
}
return 0;
}问题 I: 不一样的走楼梯
时间限制: 1 Sec 内存限制: 128 MB提交: 903 解决: 252
有一个楼梯共M级，刚开始你在第零级，若你每次可以跨小于等于M的任意级（也就是说，你可以跨1级，2级....M级），那么要走上第M级，共有多少种走法呢？结果可能有点大，输出对1000000009取余后的结果~
多组输入，以文件尾结束
每行一个数M代表想要跳上第M级（0<M<=10000）
每行一个数，代表跳上M级有多少种方法
1
1
代码：
#include<iostream>
#include<string>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<queue>
#include<cstring>
#include<map>
using namespace std;
typedef long long ll;
#define mod 1000000009
ll m;
ll sum[10005];
void init()
{
int i,j;
sum[0]=0;
for(i=1;i<=10000;i++)
{
sum[i]=1;
for(j=1;j<i;j++)
{
sum[i]=sum[i]+sum[j];
sum[i]=sum[i]%mod;
}
}
}
int main()
{
init();
while(cin>>m){
cout<<sum[m]<<endl;
}
return 0;
}
问题 J: Jack的宝物问题
时间限制: 1 Sec 内存限制: 128 MB提交: 612 解决: 78
Jack是个吃鸡玩家，一个偶然的机会Jack来到了神秘的P城，Jack发现P城有 N 种宝物，每种宝物有 x[i] 个。但是当Jack想把他们全部拿走时，Jack发现由于背包限制，Jack现在只能带 3 件宝物回去，且每种宝物Jack最多只能带走 1 件。那么Jack一共有多少种带走 3 种不同宝物的方法？
3
1 2 3
6
其实看到题目就是明显的动态规划，但是暴力做也可以，这个题才开始我多乘了一个C(m,3)意思是先取个组合数，其实是不用的，
dp[i][j]是说到第i种宝物时已经拿了j+1个的情况
dp[i][0]=(x[i]+dp[i-1][0])是到第i种宝物时，总共拿了1个，那么可以在第i种的x[i]个中拿一个（方案数就是x[i]），也可以不拿
dp[i][1]=(dp[i-1][0]*x[i]%mod+dp[i-1][1])是到第i种宝物时，总共拿了2个，那么可以在第i种的x[i]个中拿一个（方案数就是之前拿1个的方案数*这里再拿一个的方案数：(dp[i-1][0]*x[i]），也可以不拿（就是之前已经拿2个的方案数）
dp[i][2]=(dp[i-1][1]*x[i]%mod+dp[i-1][2])是到第i种宝物时，总共拿了3个，那么可以在第i种的x[i]个中拿一个（方案数就是之前拿2个的方案数*这里再拿一个的方案数：(dp[i-1][1]*x[i]），也可以不拿（就是之前已经拿3个的方案数）
动态规划：
#include<iostream>
#include<string>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<queue>
#include<cstring>
#include<map>
using namespace std;
typedef long long ll;
#define mod 609929123
ll m;
ll x[2005],dp[2005][3]; //dp[i][j]是说到第i种宝物时已经拿了j+1个的情况
ll C(ll n,ll m)
{
ll ans=n*(n-1)*(n-2);
ans=ans/6;
ans=ans%mod;
return ans;
}
ll work()
{
int i;
dp[1][1]=dp[1][2]=dp[2][2]=0;
dp[1][0]=x[1];
dp[2][0]=x[2]+dp[1][0];
dp[2][1]=(dp[1][0]*x[2]+dp[1][1]);
for(i=3;i<=m;i++)
{
dp[i][0]=(x[i]+dp[i-1][0])%mod;
dp[i][1]=(dp[i-1][0]*x[i]%mod+dp[i-1][1])%mod;
dp[i][2]=(dp[i-1][1]*x[i]%mod+dp[i-1][2])%mod;
}
return dp[m][2]%mod;
}
int main()
{
int i;
while(cin>>m){
for(i=1;i<=m;i++)
cin>>x[i];
ll cnt=work();
cout<<cnt<<endl;
}
return 0;
}或者
简单点：
#include<iostream>
#include<string>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<queue>
#include<cstring>
#include<map>
using namespace std;
typedef long long ll;
#define mod 609929123
ll m;
ll x[2005],sum[2005];
int main()
{
int i,j;
while(scanf("%lld",&m)!=EOF){
for(i=1;i<=m;i++)
{
scanf("%lld",&x[i]);
sum[i]=sum[i-1]+x[i];
}
//cout<<ans<<endl;
ll cnt=0;
for(i=1;i<=m-2;i++)
{
for(j=i+1;j<=m-1;j++)
{
cnt=(cnt+x[i]*x[j]*(sum[m]-sum[j]))%mod;
}
}
cnt=cnt%mod;
cout<<cnt<<endl;
}
return 0;
}
问题 L: 小李子的老年生活
时间限制: 1 Sec 内存限制: 128 MB提交: 702 解决: 25
小李子有n-1个朋友，分别编号为1..n-1,小李子的编号是n ,小李子的表面朋友的编号会与小李子编号互质
我们定义小李子老年生活的悲惨度是表面朋友的编号的平方和
多组输入(小于等于10000组)
每组输入一个n（ <= 1e6 )
输出小李子的悲惨度
2
3
1
5
具体和这个题差不多： HDU - 4059 The Boss on Mars - （容斥定理，1~n的4次方之和）
代码：
#include<iostream>
#include<string>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<queue>
#include<cstring>
#include<map>
using namespace std;
typedef long long ll;
#define mod 609929123
vector<ll>prime;
ll n,len;
ll sum[1000005];
void init_sum() //1~n的2次方之和，要进行预处理否则超时
{
ll ans=0;
for(ll i=1;i<=1000000;i++)
{
ans+=i*i;
sum[i]=ans;
}
}
void init(ll tn) //将n分解质因数
{
prime.clear();
for(ll i=2;i*i<=tn;i++)
{
if(tn%i==0)
{
prime.push_back(i);
while(tn%i==0)
tn=tn/i;
}
}
if(tn>1)
prime.push_back(tn);
len=prime.size();
}
ll solve() //1~n中与n不互素的数的平方之和
{
ll ans=0;
for(ll msk=1;msk<(1ll<<len);msk++)
{
ll bits=0,cnt=1;
for(ll i=0;i<len;i++)
{
if(msk&(1ll<<i))
{
bits++;
cnt*=prime[i];
}
}
if(bits&1)
{
ans+=(cnt*cnt)*sum[n/cnt]; //(cnt*cnt)*sum[n/cnt]为cnt倍数的平方之和
}else{
ans-=(cnt*cnt)*sum[n/cnt];
}
}
return ans;
}
int main()
{
init_sum();
while(scanf("%lld",&n)!=EOF)
{
if(n==0||n==1) //注意n等于1时输出0
{
printf("0\n");
continue;
}
init(n);
ll ans=sum[n];
ans=ans-solve();
printf("%lld\n",ans);
}
return 0;
}
1301
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
