小易有一个长度为n的整数序列,a_1,...,a_n。然后考虑在一个空序列b上进行n次以下操作:
1、将a_i放入b序列的末尾
2、逆置b序列
小易需要你计算输出操作n次之后的b序列。
输入描述:
输入包括两行,第一行包括一个整数n(2 ≤ n ≤ 2*10^5),即序列的长度。 第二行包括n个整数a_i(1 ≤ a_i ≤ 10^9),即序列a中的每个整数,以空格分割。
输出描述:
在一行中输出操作n次之后的b序列,以空格分割,行末无空格。
输入例子1:
4 1 2 3 4
输出例子1:
4 2 1 3
思路：观察找规律，发现是：左右摇摆填充数据
package l4;
import java.util.Scanner;
/*
* 观察
*/
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] a = new int[n], b = new int[n];
for(int i=0; i<n; i++) a[i] =sc.nextInt();
int t = 0, pl = n/2-1, pr = n/2+1;
b[n/2] = a[t++];
boolean left = n%2==0 ? true : false;
if(left) b[pl--] = a[t++];
while(pr - pl <= n-1) {
b[pr++] = a[t++];
b[pl--] = a[t++];
}
for(int i=0; i<n-1; i++)
System.out.print(b[i] + " ");
System.out.println(b[n-1]);
}
}
小易将n个棋子摆放在一张无限大的棋盘上。第i个棋子放在第x[i]行y[i]列。同一个格子允许放置多个棋子。每一次操作小易可以把一个棋子拿起并将其移动到原格子的上、下、左、右的任意一个格子中。小易想知道要让棋盘上出现有一个格子中至少有i(1 ≤ i ≤ n)个棋子所需要的最少操作次数.
输入描述:
输入包括三行,第一行一个整数n(1 ≤ n ≤ 50),表示棋子的个数 第二行为n个棋子的横坐标x[i](1 ≤ x[i] ≤ 10^9) 第三行为n个棋子的纵坐标y[i](1 ≤ y[i] ≤ 10^9)
输出描述:
输出n个整数,第i个表示棋盘上有一个格子至少有i个棋子所需要的操作数,以空格分割。行末无空格 如样例所示: 对于1个棋子: 不需要操作 对于2个棋子: 将前两个棋子放在(1, 1)中 对于3个棋子: 将前三个棋子放在(2, 1)中 对于4个棋子: 将所有棋子都放在(3, 1)中
输入例子1:
4 1 2 4 9 1 1 1 1
输出例子1:
0 1 3 10思路：最开始认为是放到选定点的中间，然后想DFS遍历
* 后来发现可以分别将点投影到坐标轴，求x，y坐标
* 在一条直线上求距离和最小的点，这样的点有无数个
* 而其中原来的点至少一个点是正解，用反证法证明（这种方法只适合于一维情况）
感觉网易每年都有类似的枚举题？枚举所有可能的xy
package l6;
import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Scanner;
/*
* 最开始认为是放到选定点的中间，然后想DFS遍历
* 后来发现可以分别将点投影到坐标轴，求x，y坐标
* 在一条直线上求距离和最小的点，这样的点有无数个
* 而其中原来的点至少一个点是正解，用反证法证明（这种方法只适合于一维情况）
*
* WA??
*/
public class WA {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] a = new int[n], b = new int[n];
for(int i=0; i<n; i++) a[i] =sc.nextInt();
for(int i=0; i<n; i++) b[i] =sc.nextInt();
int[] ret = new int[n+1];
Arrays.fill(ret, Integer.MAX_VALUE);
int[][] adjx = new int[a.length][a.length], adjy = new int[a.length][a.length];
for(int i=0; i<a.length; i++)
for(int j=0; j<a.length; j++) {
adjx[i][j] = Math.abs(a[i]-a[j]);
adjy[i][j] = Math.abs(b[i]-b[j]);
}
// 然后遍历adj的每行，求出topK
// 这里错在如果选2个点：不能选x的时候用AB两点，选y用CD两点
for(int i=1; i<=n; i++) {
int minx = Integer.MAX_VALUE, miny = Integer.MAX_VALUE;
for(int j=0; j<a.length; j++) {
int sumx = 0, sumy = 0;
PriorityQueue<Integer> pq = new PriorityQueue<Integer>(n, new Comparator<Integer>(){
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
});
for(int k=0; k<i; k++) pq.add(adjx[j][k]);
for(int k=i; k<n; k++) {
pq.add(adjx[j][k]);
pq.remove();
}
while(!pq.isEmpty()) sumx += pq.remove();
minx = Math.min(minx, sumx);
for(int k=0; k<i; k++) pq.add(adjy[j][k]);
for(int k=i; k<n; k++) {
pq.add(adjy[j][k]);
pq.remove();
}
while(!pq.isEmpty()) sumy += pq.remove();
miny = Math.min(miny, sumy);
ret[i] = Math.min(ret[i], minx + miny);
}
}
for(int i=1; i<n; i++)
System.out.print(ret[i] + " ");
System.out.println(ret[n]);
}
}* 因为既然x，y都是原来数据点中的值，最后那个点的位置是有限的
* 就2层循环遍历x和y的所有可能值就好了
最好的点不一定是所有点中的一个，但是x坐标一定是所有x坐标中的一个，y也是
from itertools import accumulate
n=int(input())
xs=list(map(int,input().strip().split(' ')))
ys=list(map(int,input().strip().split(' ')))
dist = []
for x in xs:
for y in ys:
t = sorted([abs(x-xx)+abs(y-yy) for xx,yy in zip(xs,ys)])
dist.append(list(accumulate(t)))
res = [min([dist[j][i] for j in range(len(dist))]) for i in range(n)]
print(' '.join(map(str,res)))
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] a = new int[n], b = new int[n];
for(int i=0; i<n; i++) a[i] =sc.nextInt();
for(int i=0; i<n; i++) b[i] =sc.nextInt();
int[] ret = new int[n+1];
Arrays.fill(ret, Integer.MAX_VALUE);
for(int i=1; i<=n; i++) {
int min = Integer.MAX_VALUE;
for(int p=0; p<a.length; p++) {
for(int q=0; q<b.length; q++) {
int sum = 0;
PriorityQueue<Integer> pq = new PriorityQueue<Integer>(n, new Comparator<Integer>(){
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
});
for(int k=0; k<i; k++) pq.add(Math.abs(a[k]-a[p]) + Math.abs(b[k]-b[q]));
for(int k=i; k<n; k++) {
pq.add(Math.abs(a[k]-a[p]) + Math.abs(b[k]-b[q]));
pq.remove();
}
while(!pq.isEmpty()) sum += pq.remove();
min = Math.min(min, sum);
}
}
ret[i] = min;
}
for(int i=1; i<n; i++)
System.out.print(ret[i] + " ");
System.out.println(ret[n]);
}
}
小易老师是非常严厉的,它会要求所有学生在进入教室前都排成一列,并且他要求学生按照身高不递减的顺序排列。有一次,n个学生在列队的时候,小易老师正好去卫生间了。学生们终于有机会反击了,于是学生们决定来一次疯狂的队列,他们定义一个队列的疯狂值为每对相邻排列学生身高差的绝对值总和。由于按照身高顺序排列的队列的疯狂值是最小的,他们当然决定按照疯狂值最大的顺序来进行列队。现在给出n个学生的身高,请计算出这些学生列队的最大可能的疯狂值。小易老师回来一定会气得半死。
输入描述:
输入包括两行,第一行一个整数n(1 ≤ n ≤ 50),表示学生的人数 第二行为n个整数h[i](1 ≤ h[i] ≤ 1000),表示每个学生的身高
输出描述:
输出一个整数,表示n个学生列队可以获得的最大的疯狂值。 如样例所示: 当队列排列顺序是: 25-10-40-5-25, 身高差绝对值的总和为15+30+35+20=100。 这是最大的疯狂值了。
输入例子1:
5 5 10 25 40 25
输出例子1:
100分类讨论，先写出奇偶情况下的可能情况
* 奇数以5为例，无非是2中情况：低高低高低， 高低高低高（2者数的分配发生了变化）
* 偶数就一种情况：低高低高（高低高低算出来是一样的）
public class CopyOfMain {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] a = new int[n];
for(int i=0; i<n; i++) a[i] =sc.nextInt();
Arrays.sort(a);
int ret = 0;
if(n % 2 == 1) {
// 低高低高低
int large = 2 * getSum(a, n/2+1, n-1);
int small = 2 * getSum(a, 0, n/2-2) + a[n/2-1] + a[n/2];
ret = Math.max(ret, large - small);
// 高低高低高
large = 2 * getSum(a, n/2+2, n-1) + a[n/2] + a[n/2+1];
small = 2 * getSum(a, 0, n/2-1);
ret = Math.max(ret, large - small);
} else {
int large = 2 * getSum(a, n/2+1, n-1) + a[n/2];
int small = 2 * getSum(a, 0, n/2-2) + a[n/2-1];
ret = Math.max(ret, large - small);
}
System.out.println(ret);
}
private static int getSum(int[] a, int i, int j) {
int ret = 0;
for(int k=i; k<=j; k++) ret+=a[k];
return ret;
}
}
小易非常喜欢拥有以下性质的数列:
1、数列的长度为n
2、数列中的每个数都在1到k之间(包括1和k)
3、对于位置相邻的两个数A和B(A在B前),都满足(A <= B)或(A mod B != 0)(满足其一即可)
例如,当n = 4, k = 7
那么{1,7,7,2},它的长度是4,所有数字也在1到7范围内,并且满足第三条性质,所以小易是喜欢这个数列的
但是小易不喜欢{4,4,4,2}这个数列。小易给出n和k,希望你能帮他求出有多少个是他会喜欢的数列。
输入描述:
输入包括两个整数n和k(1 ≤ n ≤ 10, 1 ≤ k ≤ 10^5)
输出描述:
输出一个整数,即满足要求的数列个数,因为答案可能很大,输出对1,000,000,007取模的结果。
输入例子1:
2 2
输出例子1:
3思路：直接DP，优化了一下还是TLE
/*
* dp
*/
public class tle {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt(), k = sc.nextInt();
long[][] dp = new long[1+n][1+k];
for(int i=1; i<=k; i++) dp[1][i] = 1;
for(int i=2; i<=n; i++) {
int tmp = 0;
for(int j=1; j<=k; j++) {
// for(int t=1; t<=j; t++) {
// dp[i][j] += dp[i-1][t];
// dp[i][j] %= 1000000007;
// }
tmp += dp[i-1][j];
dp[i][j] += tmp;
for(int t=j+1; t<=k; t++) {
if(t % j != 0) {
dp[i][j] += dp[i-1][t];
dp[i][j] %= 1000000007;
}
}
}
}
long ret = 0;
for(int i=1; i<=k; i++) ret+=dp[n][i];
System.out.println(ret%1000000007);
}
}先获得所有可能结果，再减去约数
public class CopyOfMain {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt(), k = sc.nextInt();
long[][] dp = new long[1+n][1+k];
for(int i=1; i<=k; i++) dp[1][i] = 1;
for(int i=2; i<=n; i++) {
long preSum = 0;
for(int j=1; j<=k; j++) {
preSum += dp[i-1][j];
dp[i][j] %= 1000000007;
}
for(int j=1; j<=k; j++) {
int deductSum = 0;
for(int t=j+1; t<=k; t++) {
if(t % j == 0) {
deductSum += dp[i-1][t];
dp[i][j] %= 1000000007;
}
}
dp[i][j] = preSum - deductSum;
}
}
long ret = 0;
for(int i=1; i<=k; i++) ret+=dp[n][i];
System.out.println(ret%1000000007);
}
}求倍数还可以再优化
直接遍历太慢了，因为知道其中一个约数，遍历另外一个约数会快一点
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt(), k = sc.nextInt();
long[][] dp = new long[1+n][1+k];
for(int i=1; i<=k; i++) dp[1][i] = 1;
for(int i=2; i<=n; i++) {
long preSum = 0;
for(int j=1; j<=k; j++) {
preSum += dp[i-1][j];
preSum %= 1000000007;
}
for(int j=1; j<=k; j++) {
long deductSum = 0;
int t = 2;
while(t * j <= k) {
deductSum += dp[i-1][t*j];
deductSum %= 1000000007;
t ++;
}
dp[i][j] = preSum - deductSum;
}
}
long ret = 0;
for(int i=1; i<=k; i++) {
ret+=dp[n][i];
ret %= 1000000007;
}
System.out.println((ret+1000000007)%1000000007);
}
}
总结：自己的能力还是有限啊，稍微难一点的提就做不出来了，还有不到一年的时间就找工作了，还要发文章啊。。。。
がんばってください
话说网易怎么这么喜欢出找规律的题目？？
扫一扫
3787
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
