矩阵问题

建物流中站

题目描述
Shopee物流会有很多个中转站。在选址的过程中，会选择离用户最近的地方建一个物流中转站。

假设给你一个二维平面网格，每个格子是房子则为1，或者是空地则为0。找到一个空地修建一个物流中转站，使得这个物流中转站到所有的房子的距离之和最小。 能修建，则返回最小的距离和。如果无法修建，则返回 -1。

若范围限制在100*100以内的网格，如何计算出最小的距离和？

当平面网格非常大的情况下，如何避免不必要的计算？

解题思路：求出横向竖向所有为1的坐标的均值，在离这个点最近的0处建立；

import java.util.ArrayList;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[][] array = new int[n][n];
        boolean f=false;
        ArrayList<String> list2 = new ArrayList<>();
        ArrayList<String> list1 = new ArrayList<>();
        int sumI=0;
        int sumJ=0;
        int num=0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                array[i][j]=sc.nextInt();
                if (array[i][j]==0){
                    f=true;
                    if (i!=0&&j!=0){
                        list2.add(i+" "+j);
                    }
                }else {
                    sumI+=i;
                    sumJ+=j;
                    num++;
                    list1.add(i+" "+j);
                }
            }
        }
        if (!f){
            System.out.println(-1);
            return;
        }
        float a=sumI/num;
        float b=sumJ/num;
        int x=0;
        int y=0;
        float min=Float.MAX_VALUE;
        for (int i = 0; i < list2.size(); i++) {
            String s = list2.get(i);
            String[] split = s.split(" ");
            int c=Integer.parseInt(split[0]);
            int d=Integer.parseInt(split[1]);
            float tmp= (float) (Math.pow(Math.abs(c-a),2)+Math.pow(Math.abs(b-d),2));
            if (min>tmp){
                min=tmp;
                x=c;
                y=d;
            }
        }
        int result=0;
        for (int i = 0; i < list1.size(); i++) {
            String[] split = list1.get(i).split(" ");
            int x1 = Integer.parseInt(split[0]);
            int y1 = Integer.parseInt(split[1]);
            result+=(Math.abs(x-x1)+Math.abs(y-y1));
        }
        System.out.println(result);

    }
}

有序矩阵中第K小的元素

给定一个 n x n 矩阵，其中每行和每列元素均按升序排序，找到矩阵中第k小的元素。
请注意，它是排序后的第k小元素，而不是第k个元素。

import java.util.LinkedList;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int k = sc.nextInt();
        int n = sc.nextInt();
        LinkedList<Integer> list = new LinkedList<>();
        list.add(0,sc.nextInt());
        for (int i = 1; i < n * n; i++) {
            int t=i;
            int j = sc.nextInt();
            if (list.get(t-1)>j){
                while (list.get(t-1)>j){
                    if (t!=i)
                        list.remove(t);
                    list.add(t,list.get(t-1));
                    list.remove(t-1);
                    list.add(t-1,j);
                    t--;
                }
            }else {
                list.add(t,j);
            }
        }
        System.out.println(list.get(k-1));
    }
}

顺时针输出N*N的矩阵

 public static ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> array= new ArrayList<>();
        int n= matrix.length,x=0,y=0;
        int spect=n;
        printf(array,matrix,n,x,y,spect);
        return array;
    }

    private static void printf(ArrayList array,int[][] matrix,int n,int x,int y,int spect){

        if(spect%2!=0&&n<=(spect-1)/2){
            return;
        }
        if(spect%2==0&&n<=spect/2){
            return;
        }

        for (int i = x; i <n; i++) {
            array.add(matrix[x][i]);
        }

        for (int i = y+1; i <n; i++) {
            array.add(matrix[i][n-1]);
        }
        for (int i=n-2;i>=x;i--){
            array.add(matrix[n-1][i]);
        }
        for (int i=n-2;i>=y+1;i--){
            array.add(matrix[i][y]);
        }
        printf(array,matrix,n-1,x+1,y+1,spect);

    }