Question

我正在对优步赞助的Codefights进行编码挑战，并且存在一个我无法解决的问题。对于这个问题，你可以看看http://codepen.io/ducminhn/pen/JYmrmE。

我认为这个问题与动态编程有关，所以我将这个问题标记为动态编程，但我还在学习Java，所以如果我错了请通知我。这是我到目前为止所做的，我相信我的逻辑在嵌套的for循环中可能不正确。如果有人可以请查看我的代码并为我修复它。

提前致谢，

boolean parkingSpot(int[] carDimensions, int[][] parkingLot, int[] luckySpot) {

int carx = carDimensions[0];
int cary = carDimensions[1];

boolean result = false;
for(int l=0;l<parkingLot.length;l++){
    for(int k=0;k<parkingLot.length;k++){
        if(l == luckySpot[0]){
            for(int i=luckySpot[0];i<carx;i++){
                if(k== luckySpot[1]){
                    for(int j= luckySpot[1];j<cary;j++){
                        if(parkingLot[i][j] != 0){
                            result = false;
                        }
                   }
                }
            }
        }
    }   
 }
 return true;
}

Answer 1

这似乎比你做的更复杂......所以不太确定它是否有帮助。我只是根据给定的例子对它进行了测试，但如果我没有完全误解问题，你可以使用几个循环，所以没有明显的动态编程使用。

    static boolean h(int[] luckySpot,int[][] parkingLot){
        // check if parking spot given contains a 1
        // (check if it's a valid parking spot)
        for(int i=luckySpot[0];i<=luckySpot[2];i++){
            for(int j=luckySpot[1];j<=luckySpot[3];j++){
                if(parkingLot[i][j]==1) return false;
            }
        }

        // check if the car parked vertically
        if(     Math.abs(luckySpot[0]-luckySpot[2]) > 
                Math.abs(luckySpot[1]-luckySpot[3])) {

            // check for empty path going to the top
            outerloop:
            for(int i=0;i<luckySpot[0];i++){
                for(int j=luckySpot[1];j<=luckySpot[3];j++){
                    if(parkingLot[i][j]==1) break outerloop;
                }
                if(i==luckySpot[0]-1) return true;
            }

            // check for empty path going to the bottom
            for(int i=luckySpot[2]+1;i<parkingLot.length;i++){
                for(int j=luckySpot[1];j<=luckySpot[3];j++){
                    if(parkingLot[i][j]==1) return false;
                }
                if(i==parkingLot.length-1) return true;
            }

        }
        // the car parked horizontally
        else{
            // check for empty path going to the left
            outerloop:
            for(int i=luckySpot[0];i<=luckySpot[2];i++){
                for(int j=0;j<luckySpot[1];j++){
                    if(parkingLot[i][j]==1) break outerloop;
                }
                if(i==luckySpot[2]) return true;
            }

            // check for empty path going to the right
            for(int i=luckySpot[0];i<=luckySpot[2];i++){
                for(int j=luckySpot[3]+1;j<parkingLot[0].length;j++){
                    if(parkingLot[i][j]==1) return false;
                }
                if(i==luckySpot[2]) return true;
            }

        }

        return false;
    }


    public static void main(String[] args) {

        /*
        "for safety reasons, the car can only move in two directions inside
        the parking lot -- forwards or backwards along the long side of the car"
        i assume this to mean that the direction the car travels is parallel
        to the long side of the car
         */


        int[] carDimensions = {3, 2};

        int [][] parkingLot = {
                {1, 0, 1, 0, 1, 0},
                {1, 0, 0, 0, 1, 0},
                {1, 0, 0, 0, 0, 1},
                {1, 0, 0, 0, 1, 1}
        };
        int[] luckySpot={1, 1, 2, 3};


        System.out.println(h(luckySpot,parkingLot));


    }

停车位功能给出停车场阵列和汽车尺寸

1 个答案: