求在一个格子里出现n棋子的最少操作数

题目

小易将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

代码:

import java.util.*;
public class Main{
    public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		while (sc.hasNextInt()) {
			int n = sc.nextInt();
            int[]x = new int[n];
            int[]y = new int[n];
            for(int i=0;i<n;i++){   //
                x[i] = sc.nextInt();
               
            }
            
            for(int i=0;i<n;i++){   //
                y[i] = sc.nextInt();
               
            }
			int[] res = minOPs(n, x, y);
			StringBuilder result = new StringBuilder();
			for (int i = 0; i < n; i++) {
                if(i!=n-1){
                    System.out.print(res[i]+" ");
                }else{
                    System.out.print(res[i]);
                }
			}
		}
		sc.close();
	}

	public static int[] minOPs(int n, int[] x, int[] y) {
		 Queue<Integer> pq = new PriorityQueue<Integer>();
        int[]res = new int[n];
        for(int i=0;i<n;i++){
            res[i] = Integer.MAX_VALUE;
        }
        
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                for(int k=0;k<n;k++){
                    int temp = Math.abs(x[i]-x[k])+Math.abs(y[j]-y[k]);
                    pq.offer(temp);
                }
                int index =0;
                int sum=0;
                while(!pq.isEmpty()){
                    sum += pq.poll();
                    res[index] = Math.min(sum,res[index]);
                    index++;
                }
            }
        }
        return res;

	}
}


能否帮我对答案的统计进行完善并给出解释 #include<bits/stdc++.h> using namespace std; const int MAXN = 15; int N, ans1 = 0x3f3f3f3f, ans2 = 0x3f3f3f3f; int a[MAXN][MAXN], now[MAXN][5], dist[MAXN][MAXN], ans[MAXN][5]; int head[MAXN], cnt; struct star{ int nxt, to, w; }edge[MAXN * 4]; void add( int u, int v, int w ){ // cout << u << " " << v << " " << w - 10000 << endl; dist[u][v] = w; dist[v][u] = w; // edge[++ cnt] = { head[u], v, w }; // head[u] = cnt; } //================star_edge int fx1[] = { 2, 1, -2, -1 }; int fy1[] = { 1, 2, -1, -2 }; bool vis[MAXN][MAXN]; void rook(){ for( int i = 1; i <= N; i ++ ){ for( int j = 1; j <= N; j ++ ){ for( int k = 1; k <= N; k ++ ){ add( a[i][j], a[i][k], 10000 ); add( a[i][k], a[i][j], 10000 ); add( a[i][j], a[k][j], 10000 ); add( a[k][j], a[i][j], 10000 ); } } } } void knight( int x, int y, int cnt ){ if( cnt >= N * N ) return ; vis[x][y] = true; for( int i = 0; i < 4; i ++ ){ int nx = fx1[i] + x; int ny = fy1[i] + y; if( nx >= 1 && ny >= 1 && nx <= N && ny <= N && !vis[nx][ny] ){ vis[nx][ny] = true; add( a[x][y] + N * N, a[nx][ny] + N * N, 10000 ); add( a[nx][ny] + N * N, a[x][y] + N * N, 10000 ); knight( nx, ny, cnt + 1 ); vis[nx][ny] = false; } } } void bishop(){ for( int i = 1; i <= N; i ++ ){ for( int j = 1; j <= N; j ++ ){ for( int k = 1; k <= N; k ++ ){ int t = i + j - k; if( t <= 0 || t > N ) continue; add( a[i][j] + N * N * 2, a[k][t] + N * N * 2, 10000 ); add( a[k][t] + N * N * 2, a[i][j] + N * N * 2, 10000 ); } } } } void hebing(){ for( int i = 1; i <= N; i ++ ){ add( i, i + N * N, 10001 ); add( i + N * N, i, 10001 ); add( i, i + N * N * 2, 10001 ); add( i + N * N * 2, i, 10001 ); add( i + N * N, i + N * N * 2, 10001 ); add( i + N * N * 2, i + N * N, 10001 ); } } //================add_edge void floyd(){ for( int k = 1; k <= N; k ++ ){ for( int i = 1; i <= N; i ++ ){ for( int j = 1; j <= N; j ++ ){ dist[i][j] = min( dist[i][j], dist[i][k] + dist[k][j] ); } } } } int main(){ cin >> N; memset( dist, 0x3f, sizeof( dist ) ); for( int i = 1; i <= N; i ++ ){ for( int j = 1; j <= N; j ++ ){ cin >> a[i][j]; now[a[i][j]][1] = i; now[a[i][j]][2] = j; } } rook(); knight( 1, 1, 1 ); bishop(); hebing(); floyd(); for( int i = 1; i <= N * N; i ++ ){ // int x = now[i][1], y = now[i][2]; // cout << dist[x][y] / 10000 << " " << dist[x][y] % 10000 << endl; // ans1 += dist[x][y] / 10000; // ans2 += ans2, dist[x][y] % 10000; } cout << ans1 << " " << ans2; return 0; } ```不要改变变量名、思路和算法,不要使用复杂的变量名,迫不得已使用简短的变量名来创建变量,顺便看看前面的代码有没有问题,如有问题,请修改并且标记出,不要改变原来的结构 题面如下# CF1065D Three Pieces ## 题目描述 你遇到了一种新型的国际象棋谜题。你得到的棋盘不一定是 $8 \times 8$,但它仍然是 $N \times N$ 的。每个格子上都写有一个数字,所有数字都是从 $1$ 到 $N^2$,且两两不同。第 $i$ 行第 $j$ 列的格子上写着数字 $A_{ij}$。 你的棋子只有三种:马、象和车。开始时,你可以任选一种棋子放在数字为 $1$ 的格子上。然后你需要依次到达数字为 $2$ 的格子(过程中可以经过其他格子),再到数字为 $3$ 的格子,依此类推,直到到达数字为 $N^2$ 的格子。每一步你可以选择用当前棋子进行一次合法移动,或者将当前棋子更换为另一种棋子。每个格子可以被多次经过。 马可以移动到横向两格纵向一格,或纵向两格横向一格的格子。象可以沿对角线移动。车可以沿横向或纵向移动。每次移动都必须到达与当前格子不同的格子。 你希望使整个遍历过程的步数最少。在所有步数相同的方案中,你还希望棋子更换次数最少。 你应该采取怎样的路径以满足所有条件? ## 输入格式 第一行包含一个整数 $N$($3 \le N \le 10$),表示棋盘的大小。 接下来的 $N$ 行,每行包含 $N$ 个整数 $A_{i1}, A_{i2}, \dots, A_{iN}$($1 \le A_{ij} \le N^2$),表示棋盘上每个格子上的数字。 保证所有 $A_{ij}$ 两两不同。 ## 输出格式 输出一行,包含两个整数,分别表示最优方案的步数和更换棋子的次数。 ## 输入输出样例 #1 ### 输入 #1 3 1 9 3 8 6 7 4 2 5 ### 输出 #1 12 1 ## 说明/提示 以下是第一个样例的步骤(起始棋子为马): 1. 移动到 $(3, 2)$ 2. 移动到 $(1, 3)$ 3. 移动到 $(3, 2)$ 4. 更换马为车 5. 移动到 $(3, 1)$ 6. 移动到 $(3, 3)$ 7. 移动到 $(3, 2)$ 8. 移动到 $(2, 2)$ 9. 移动到 $(2, 3)$ 10. 移动到 $(2, 1)$ 11. 移动到 $(1, 1)$ 12. 移动到 $(1, 2)$ 由 ChatGPT 4.1 翻译
最新发布
07-23
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值