阶乘之和
例1 ：阶乘之和
输入n，计算S=1!+2! + 3!+…+n!的末6位（不含前导0)。n≤10^6，n!表示前n个正整数之积。
样例输入：
10
样例输出：
37913
代码：
#include<stdio.h>
int main ()
{
int n, S=0 ;
scanf ("%d", &n);
for(int i=1; i<= n; i++)
{
int factorial = 1; //每执行一次循环都要重新初始化为1
for(int j =1;j <= i; j++)
{factorial *= j;} //累加完成后才累乘 注意花括号位置
S+=factorial;
}
printf("%d\n",S % 1000000);
return 0;
}
核心算法：
核心算法是累加 “for(int i= 1; i <=n; i++) S+=i!”。
不过还需要一次循环来计算i!，即“for(int j=1;j <= i;j++) factorial *=j;”。
快排
核心思想：
分治思想
1、确定分界点 x（q[L]、q[(L+R)/2]、q[R}、随机)
2、难点：调整区间 （让第一个区间都<=x；第二个区间都>=x)
3、递归处理左右两段
例2 ：快排
给定你一个长度为n的整数数列。
请你使用快速排序对这个数列按照从小到大进行排序。并将排好序的数列按顺序输出。
输入格式
输入共两行，第一行包含整数n。
第二行包含n个整数(所有整数均在1~10^9范围内)，表示整个数列。
输出格式
输出共一行，包含n个整数，表示排好序的数列。
数据范围
1 ≤ n ≤1000000
输入样例:
5
3 1 24 5
输出样例:
12345
代码：
#include<iostream>
using namespace std;
const int N=1e6+10;
int n;
int q[N];
void quick_sort(int q[],int l, int r)
{
if(l>=r) return;
int x=q[l],i=l-1,j=r+1;
while(i<j)
{
do i++;while (x>q[i]);
do j--;while (x<q[j]);
if(i<j) swap(q[i],q[j]);
}
quick_sort(q,l,j); //分治思想
quick_sort(q,j+1,r);
}
int main()
{
cin>>n;
for(int i=0;i<n;i++){
cin>>q[i];}
quick_sort(q,0,n-1);
for(int i=0;i<n;i++){
cout<<q[i];}
return 0;
}
归并
核心思想：
分治思想
1、确定分界点mid （mid=（L+R）/2）
2、递归排序left、right部分
3、难点：把两个有序序列合二为一
例3 ：归并排序
给定你一个长度为n的整数数列。
请你使用归并排序对这个数列按照从小到大进行排序。并将排好序的数列按顺序输出。
输入格式
输入共两行，第一行包含整数n。
第二行包含n个整数(所有整数均在1~10^9范围内)，表示整个数列。
输出格式
输出共一行，包含n个整数，表示排好序的数列。
数据范围
1 ≤ n ≤1000000
输入样例:
5
3 1 24 5
输出样例:
12345
代码：
#include<iostream>
using namespace std;
const int N=1e6+10;
int n;
int q[N],tmp[N];
void merge_sort(int q[], int l, int r)
{
if (l >= r) return;
int mid = l + r >> 1; // ((l+r)/2)
merge_sort(q, l, mid);
merge_sort(q, mid + 1, r);
int k = 0, i = l, j = mid + 1;
while (i <= mid && j <= r)
if (q[i] <= q[j]) tmp[k ++ ] = q[i ++ ];
else tmp[k ++ ] = q[j ++ ];
while (i <= mid) tmp[k ++ ] = q[i ++ ];
while (j <= r) tmp[k ++ ] = q[j ++ ];
for (i = l, j = 0; i <= r; i ++, j ++ ) q[i] = tmp[j];
}
int main()
{
cin>>n;
for(int i=0;i<n;i++)
cin>>q[i];
merge_sort(q,0,n-1);
for(int i=0;i<n;i++)
cout<<q[i];
return 0;
}
ps：归并排序稳定而快速排序不稳定（不是指时间效率稳定），不稳定的原因是
多次排序相同的数可能在不同的位置，想要快速排序稳定，让每个数变不同即可，设置双关键字就可以<a[i],i>
二分
主要分为整数二分和浮点数二分。整数二分需要考虑边界，而浮点数二分比较简单不需要考虑边界。
例4 ：数的范围
给定一个按照升序排列的长度为n的整数数组，以及q个查询。
对于每个查询，返回一个元素k的起始位置和终止位置(位置从O开始计数)。如果数组中不存在该元素，则返回“-1-1”。
输入格式
第一行包含整数n和q，表示数组长度和询问个数。
第二行包含n个整数(均在1~10000范围内)，表示完整数组。接下来q行，每行包含一个整数k，表示一个询问元素。
输出格式
共q行，每行包含两个整数，表示所求元素的起始位置和终止位置。如果数组中不存在该元素，则返回"-1 -1”。
数据范围
1≤n≤1000001≤q≤100001≤k ≤10000
输入样例:
6 3
1 2 2 33 43
45
输出样例:
3 4
5 5-1 -1
代码：
#include<stdio.h>
#include<iostream>
using namespace std;
int qq;
const int N = 100010;
int n, m;
int q[N];
int bsearch_1(int l,int r)
{
while(l<r)
{
int mid = l + r >> 1;
// 说明左边界 可能还在左边，但也有可能是当前元素，所以以当前元素为右端点，向左找
if(q[mid]>=qq) r=mid;
else l = mid+1;
}
return l;
}
int bsearch_2(int l,int r)
{
while(l<r)
{
int mid = l+r+1>>1;
// 说明右边界 可能还在右边，但也有可能是当前元素，所以以当前元素为左端点，向右找
if(q[mid]>qq) r = mid-1;
else l = mid;
}
return l;
}
int main()
{
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i ++ ) scanf("%d", &q[i]);
while(m--){
scanf("%d", &qq);
int l = bsearch_1(0,n-1);
if (q[l] != qq) cout << "-1 -1" << endl;
else{
cout<<l<<" ";
l = bsearch_2(0,n-1);
cout<<l<<endl;
}
}
}
二分模板
bool check(int x) {/* ... */} // 检查x是否满足某种性质
// 区间[l, r]被划分成[l, mid]和[mid + 1, r]时使用：
int bsearch_1(int l, int r)
{
while (l < r)
{
int mid = l + r >> 1;
if (check(mid)) r = mid; // check()判断mid是否满足性质
else l = mid + 1;
}
return l;
}
// 区间[l, r]被划分成[l, mid - 1]和[mid, r]时使用：
int bsearch_2(int l, int r)
{
while (l < r)
{
int mid = l + r + 1 >> 1;
if (check(mid)) l = mid;
else r = mid - 1;
}
return l;
}
双指针算法
核心思想：
分治思想
1、确定分界点mid （mid=（L+R）/2）
2、递归排序left、right部分
3、难点：把两个有序序列合二为一
例5 ：单词换行
给定你一个字符串。每个单词之间只有一个空格。
请你将单词按空格处划开，并每个单词换行输出。
输入格式
输入共一行，第一行一串字符串。
输出格式
输出共n行，包含n个单词。
输入样例:
abc def ghi
输出样例:
abc
def
ghi
代码：
#include<iostream>
#include<string.h>
using namespace std;
int main()
{
char str[1000];
gets(str); //输入字符串
int n=strlen(str);//记录字符串长度
for (int i=0;i<n;i++)
{
int j=i;
while(j<n&&str[j]!=' ')
{
j++;
}
for(int k=i;k<j;k++)
{
cout<<str[k];
}
cout<<endl;
i=j;
}
return 0;
}
例6：最长子序列
给定一个长度为n的整数序列，请找出最长的不包含重复数字的连续子序列，输出它的长度。
输入格式
第一行包含整数n。
第二行包含n个整数(均在0~100000范围内)，表示整数序列。
输出格式
共一行，包含一个整数，表示最长的不包含重复数字的连续子序列的长度。
数据范围
1≤n ≤100000
输入样例:
5
1 2 2 3 5
输出样例:
3
#include<iostream>
using namespace std;
const int N=100010;
int n;
int a[N],s[N];
int main()
{
cin>>n;
for(int i=0;i<n;i++)
{
cin>>a[i];
}
int res=0;
for(int i=0,j=0;i<n;i++)
{
s[a[i]]++; //重复数用下标记录
while(s[a[i]]>1)
{
s[a[j]]--;
j++;
}
res=max(res,i-j+1);
}
cout<<res<<endl;
return 0;
}
位运算
位运算
1、求n的第k位数字: n >> k & 1
2、返回n的最后一位1：lowbit(n) = n & -n
n的二进制表示中第k位是几
eg. n=15=（1111） 从后往前第二位是1
n=14=（1110）第0位是0
核心思想：
1、先把第k位移到最后一位 （n>>k)
2、看个位是几
#include<iostream>
#include<string.h>
using namespace std;
int main()
{
int n;
cin>>n;
for(int k=3;k>=0;k--)
{
cout<< (n>>k&1);
}
return 0;
}
缺失的彩虹
题目描述
众所周知，彩虹有7种颜色，我们给定七个 字母和颜色 的映射，如下所示：
‘A’ -> “red”
‘B’ -> “orange”
‘C’ -> “yellow”
‘D’ -> “green”
‘E’ -> “cyan”
‘F’ -> “blue”
‘G’ -> “purple”
但是在某一天，彩虹的颜色少了几种，你能告诉PIPI哪些彩虹的颜色没有出现过吗?
输入
输入包含多组测试用例。
对于每组测试用例，输入n个合法的颜色字符串(0<=n<=100)，输出有多少种颜色没有出现过，并分别输出对应的字母。
输出
对于每一组测试样例，输出一个数字，代表缺失的颜色种数，然后按照升序输出缺失颜色对应的字母。
样例输入
3
red
orange
cyan
样例输出
4
C
D
F
G
#include<iostream>
#include<string>
#include <stdio.h>
using namespace std;
int main()
{
int n,count=0;
string w;
while(scanf("%d",&n) != EOF)
{
int count=0;
int y[100]={0};
//cin>>n;
for(int i=0;i<n;i++ )
{
cin>>w;
if(w=="red") y[0]++;
else if(w=="orange") y[1]++;
else if(w=="yellow") y[2]++;
else if(w=="green") y[3]++;
else if(w=="cyan") y[4]++;
else if(w=="blue") y[5]++;
else if(w=="purple") y[6]++;
}
for(int i=0;i<7;i++)
{
if(y[i]==0) { count++;}
}
cout<<count<<endl;
for(int i=0;i<7;i++)
{
char N='0';
if(y[i]==0) {N=i+'A'; cout<<N<<endl;}
}
}
return 0;
}
PS:注意题干要求“ 输入包含多组测试用例” 所以要用到while(scanf(“%d”,&n) != EOF)，先定义输入的n，再写while。
最小价值和
题目描述
给定 n 个整数对(ai, bi) , 每个整数对的价值是(i-1)*ai + (n-i)*bi (下标从1开始， 这里的 ai 、bi 和输入不一定对应)，然后问所有整数对的最小价值总和。
输入
输入包含多组测试用例。
对于每组测试用例，首先输入数对的数量n(n<=1e5)
接下来输入n对数对 ai bi (0<=ai,bi<=1e9)
输出
对于每组测试用例，输出这些整数对的最小价值总和。
样例输入
3
3 2
2 4
6 1
样例输出
11
提示
0 * 6 + 2 * 1 + 1 * 3 + 1 * 2 + 2 * 2 + 0 * 4 = 11
#include <iostream>
#include <algorithm>
#define N 100010
using namespace std;
typedef long long ll;
ll sum = 0;
ll a[N];
ll b[N];
//如果第一对数大于第二对数则返回true
int cmp(int i, int j) {
return (a[i] - b[i]) > (a[j] - b[j]);
}
/
int main() {
ll n;
while(scanf("%lld",&n) != EOF) //多组输入
{
sum=0;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
ll index[N];
for (int i = 0; i < n; i++) {
index[i] = i;
}
sort(index, index + n, cmp); //排序 在数组index的首地址到第n位地址之间，按照cmp函数排序
for (int i = 0; i < n; i++) {
sum += i * a[index[i]] + (n - i - 1) * b[index[i]];//加入此时i=0，则index[0]中存放的是最大差对的序号
//则a[index[0]]中放的是a[
}
cout << sum<<endl;
}
return 0;
}
思路
这是一种常见的考察排序、贪心的题目。
我们需要的就是给这些数对排个序，而排序就得知道两个数对的“大小关系”，因此我们来考察一下两个数对：
参考：最小价值和
地砖问题
题目描述
小明站在一个矩形房间里，这个房间的地面铺满了地砖，每块地砖的颜色或是红色或是黑色。小明一开始站在一块黑色的地砖上，并且小明从一块地砖可以向上下左右四个方向移动到其他的地砖上，但是他不能移动到红色地砖上，只能移动到黑色地砖上。
请你编程计算小明可以走到的黑色地砖最多有多少块。
输入
输入包含多组测试数据。
每组输入首先是两个正整数W和H，分别表示地砖的列行数。（1<=W，H<=25）
接下来H行，每行包含W个字符，字符含义如下：
‘.’表示黑地砖；
‘#’表示红地砖；
‘@’表示小明一开始站的位置，此位置是一块黑地砖，并且这个字符在每组输入中仅会出现一个。
当W=0，H=0时，输入结束。
输出
对于每组输入，输出小明可以走到的黑色地砖最多有多少块，包括小明最开始站的那块黑色地砖。
样例输入
7 7
…#.#…
…#.#…
###.###
…@…
###.###
…#.#…
…#.#…
0 0
样例输出
13
#include<bits/stdc++.h>
using namespace std;
const int N=25;
int w,h;
char a[N][N];
int vis[N][N];
int dir[4][2]={{-1,0},{1,0},{0,1},{0,-1}};
typedef struct Node{
int x,y;
}node;
int main()
{
//while(scanf("%d%d",&w,&h)&&(w||h)){
while(scanf("%d%d",&w,&h)!=EOF&&(w||h)){
//while(scanf("%d%d",&w,&h)==2&&(w||h)){
queue<node> q;
memset(vis,0,sizeof(vis));
for(int i=0;i<h;i++)
{
scanf("%s",a[i]);
for(int j=0;j<w;j++)
{
//cin>>a[i][j];
if(a[i][j]=='@')
{
q.push({i,j});
vis[i][j]=1;
}
}
}
int cnt=0;
node p;
while(!q.empty())
{
p=q.front();
q.pop();
cnt++;
for(int i=0;i<4;i++)
{
int x=p.x+dir[i][0],y=p.y+dir[i][1];
if(x>=0&&y>=0&&!vis[x][y]&&a[x][y]=='.')
{
q.push({x,y});
vis[x][y]=1;
}
}
}
cout<<cnt<<endl;
}
return 0;
}
扫一扫
8891
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
