C# 2 차원 배열의 인접 값 비교

Question

경로는 행 인덱스 80, 열 인덱스 0에서 시작합니다.이지도의 다른 가장자리 (열 인덱스 199)에 대한 경로를 만들어야합니다. 나는 이전에 방문한 셀로 돌아갈 수 없다. 현재 셀에 인접한 셀을 비교해야하지만, 다시 열을 옮길 수는 없다. 나는 계속 앞으로 나아가 야한다. 그렇지 않으면 나는 "위로"또는 "아래로 움직일 수있다. "현재 칼럼에서 나는 세포들 사이의 차이가 가장 적은 것을 발견했다.

경로를 나타 내기 위해 오른쪽으로 이동 한 오른쪽을 나타내는 (/), 오른쪽으로 이동 한 오른쪽을 나타내는 (-) 오른쪽()으로 이동해야합니다. , 또는 (|)를 나타내며 나는 위 또는 아래로 움직였다.

내가 인접 셀을 비교하는 방법에 대한 확실하지 않다 : 여기

는 내가 지금까지 가지고있는 것입니다. 나는 진술 문이 두 개 필요할 것이라고 생각하지만 나는 그것을 이해할 수 없다. 경로를 나타내는 한 무엇을 사용해야할지 모르겠습니다. 그 문자를 다른 2 차원 배열에 저장하는 별도의 방법을 만들려고했으나 제대로 작동하지 못했습니다.

static void Main(string[] args) 
    { 
     string[,] path = new string[116, 200]; 
     short[,] map = arrayMethod(); 

     int rowIndex = 80; 
     int colIndex = 0; 
     int positionOfX = 0; 
     int positionOfY = 0; 
     short minValue = short.MaxValue; 

     while (colIndex != 199) 
     { 
      for (short l = -1; l < 2; l++) 
      { 
       for (short k = 0; k < 2; k++) 
       { 
        if (map[l+ rowIndex, k+colIndex] < minValue) 
        { 
         positionOfX = l; 
         positionOfY = k; 
         minValue = map[l, k]; 
        } 
       } 
      } 
     } 
    } 
    // Method to store data into 2d array 
    public static short[,] arrayMethod() 
    { 
     short[,] map = new short[116, 200]; 

     string fileName = "land.csv"; 
     StreamReader reader = new StreamReader(File.Open(fileName, 
    FileMode.Open)); 
     string nextLine; 
     int partsCounter = 0; 
     while ((nextLine = reader.ReadLine()) != null) 
     { 
      string[] parts = nextLine.Split(','); 

      for (int cols = 0; cols < 200; cols++) 
      { 
       map[partsCounter, cols] = Convert.ToInt16(parts[cols]); 
      } 
      partsCounter++; 
     } 
     return map; 
    } 

Answer 1

는 경로 선택에 대한, 당신은 말한다 : 나는 세포의 차이의 최소 금액을 발견하고

.

나는 그걸로 돌아올 것이다. 단순 숫자 비교되어야 각 셀 어레이 내의 short 의해 표현되는 소정의 인접 셀 정보를 비교

---

,.

문제의 핵심은, 내가 믿을만한 것은 인접한 세포를 찾는 것입니다.

+-----+-----+-----+-----+ 
|  |  |  |  | 
+-----+-----+-----+-----+ 
|  |  |x,y-1|  | 
+-----+-----+-----+-----+ 
|  |x-1,y| x,y |x+1,y| 
+-----+-----+-----+-----+ 
|  |  |x,y+1|  | 
+-----+-----+-----+-----+ 

:

+-----+-----+-----+-----+ 
|  |  |  |  | 
+-----+-----+-----+-----+ 
|  |  |  |  | 
+-----+-----+-----+-----+ 
|  |  | x,y |  | 
+-----+-----+-----+-----+ 
|  |  |  |  | 
+-----+-----+-----+-----+ 

당신은 좌표를 변경하여 인접 셀을 찾을 수 1 ...

글쎄, 당신은 2D 그리드를 가지고, 당신은 하나의 셀의 좌표가 참고 : 원점이 왼쪽 상단에 있다고 가정하고 좌표를 나타냅니다. 그것이 컴퓨터 그래픽을위한 표준 컨벤션입니다. 귀하의 경우에는 적용되지 않을 수도 있습니다. 그와 상관없이, 이들은 계속 당신의 인접한 세포가됩니다.

우리는 이전 칼럼 (항상 증가해야 열 수) 나는 그것이 안전 인접한 한 것을 무시하는 생각에 돌아가서는 안 경우

+-----+-----+-----+-----+ 
|  |  |  |  | 
+-----+-----+-----+-----+ 
|  |  |x,y-1|  | 
+-----+-----+-----+-----+ 
|  |  | x,y |x+1,y| 
+-----+-----+-----+-----+ 
|  |  |x,y+1|  | 
+-----+-----+-----+-----+ 

---

우리는이 작업을 수행 할 수 있습니다

I 귀 특징으로하는 - 여기서

// the map 
short[,] map = arrayMethod(); 

// map dimensions 

int numRows = map.GetLength(0); 
int numCols = map.GetLength(1); 

// current position 
int rowIndex = 80; 
int colIndex = 0; 

while (colIndex < numCols - 1) 
{ 
    var current = map[rowIndex, colIndex]; 
    if (rowIndex > 0) 
    { 
     // We are not at the low row edge 
     var adjacent = map[rowIndex - 1, colIndex]; 
     Compare(current, adjacent); 
    } 
    if (rowIndex < numRows - 1) 
    { 
     // We are not at the high row edge 
     var adjacent = map[rowIndex + 1, colIndex]; 
     Compare(current, adjacent); 
    } 
    /*if (colIndex > 0) 
    { 
     // We are not at the low column edge 
     var adjacent = map[rowIndex, colIndex - 1]; 
     Compare(current, adjacent); 
    }*/ 
    if (/*colIndex < numCols - 1*/ true) 
    { 
     // We are not at the high column edge 
     var adjacent = map[rowIndex, colIndex + 1]; 
     Compare(current, adjacent); 
    } 
    // ... update rowIndex, colIndex 
} 

if 각 블록은 인접하는 셀들 중 하나에 대응하는 상기 이유는 가장자리에없는 경우가 있기 때문에 if 인이 확인해야 할 거짓말 쟁이 - 당신이 가장자리에 있다면, 그 방향으로 인접하지 않습니다.

또한 열에 돌아갈 해당 if에 대한 의견을 작성한 것을 확인하십시오.나는 또한 마지막 조건문을 주석으로 만들었습니다. 즉, while이 이미 그 것을 검사하고 있기 때문입니다.

나는 당신이하고 싶은 비교를 나타 내기 위해 Compare 방법을 사용하고 있습니다. 다시 돌아올 것입니다. 또한 rowIndex과 colIndex을 업데이트하지 않는다는 것을 알아 두십시오. 위 내용은 무한 루프입니다. 이 문제를 해결하려면 인접 셀을 목록으로 처리하는 것이 좋습니다. 그러면 나중에 더 쉽게 작업 할 수 있습니다. ...

부록 : 아니요, 목록이 필요 없습니다. 그것 없이도 끝날 수 있지만, 더 많은 반복을 이끌어 내고, 읽기가 더 어려우며, 오류가 더 많이 발생합니다. 이제

// the map 
short[,] map = arrayMethod(); 

// map dimensions 

int numRows = map.GetLength(0); 
int numCols = map.GetLength(1); 

// current position 
int rowIndex = 80; 
int colIndex = 0; 

while (colIndex < numCols - 1) 
{ 
    var current = map[rowIndex, colIndex]; 
    var adjacents = new List<Tuple</*row*/ short, /*column*/ short>>(); 
    if (rowIndex > 0) 
    { 
     adjacents.Add(Tuple.Create(rowIndex - 1, colIndex)); 
    } 
    if (rowIndex < numRows - 1) 
    { 
     adjacents.Add(Tuple.Create(rowIndex + 1, colIndex)); 
    } 
    adjacents.Add(Tuple.Create(rowIndex, colIndex + 1)); 
    foreach (var adjacent in adjacents) 
    { 
     Compare(map[adjacent.Item1, adjacent.Item2], current); 
    } 
    // ... update rowIndex, colIndex 
} 

...

나는 세포의 차이의 최소 금액을 발견하고있다.

내가 차이점의 절대 값으로 이해하고 있으며, 당신이 이것을 최소화하고 싶다고 추측하고 있습니다 (요구 사항은 그다지 명확하지 않습니다). 우리의 목적지

foreach (var adjacent in adjacents) 
{ 
    var diff = Math.Abs(map[adjacent.Item1, adjacent.Item2] - current); 
} 

그리고 선택 :

Tuple<short, short> best; 
short bestDiff; 
foreach (var adjacent in adjacents) 
{ 
    var diff = Math.Abs(map[adjacent.Item1, adjacent.Item2] - current); 
    if (best == null || bestDiff > diff) 
    { 
     best = adjacent; 
     bestDiff = diff; 
    } 
} 
rowIndex = best.Item1; 
colIndex = best.Item2; 

이제

---

, 부여, 당신이 다시 다시 열을 이동하거나하지 말아야을 그 이해에서

, 우리는 비교를 구현할 수 있습니다 이전 셀. 따라서 마지막 위치를 추적해야하므로 해당 위치를 확인하지 않아도됩니다. 물론

// the map 
short[,] map = arrayMethod(); 

// map dimensions 

int numRows = map.GetLength(0); 
int numCols = map.GetLength(1); 

// current position 
int rowIndex = 80; 
int colIndex = 0; 

// old position 
int rowIndexOld = 80; 
int colIndexOld = -1; // <-- placing it outside the map 

while (colIndex < numCols - 1) 
{ 
    var current = map[rowIndex, colIndex]; 
    var adjacents = new List<Tuple<short, short>>(); 
    if (rowIndex > 0 && rowIndexOld != rowIndex - 1 && colIndexOld != colIndex) 
    { 
     adjacents.Add(Tuple.Create(rowIndex - 1, colIndex)); 
    } 
    if (rowIndex < numRows - 1 && rowIndexOld != rowIndex + 1 && colIndexOld != colIndex) 
    { 
     adjacents.Add(Tuple.Create(rowIndex + 1, colIndex)); 
    } 
    if (rowIndexOld != rowIndex && colIndexOld != colIndex + 1) 
    { 
     adjacents.Add(Tuple.Create(rowIndex, colIndex + 1)); 
    } 
    rowIndexOld = rowIndex; 
    colIndexOld = colIndex; 
    // etc 
} 

---

, 당신은 경로를 선택하는 로직을 추가하고 출력에 기록 할 수 있습니다.

솔직히 말하면, 나는 요구 사항을 완전히 이해하지 못합니다. 왜 앞으로, 위, 아래로 움직일 수만 있다면 대각선 운동을 나타내는 표기가 있습니까? 대각선 당신 어쨌든, 그것은 더 힘들어되지 않습니다 : 당신이에 대한 코드를 해결할 수 있는지

+-------+-------+-------+-------+ 
|  |  |  |  | 
+-------+-------+-------+-------+ 
|  |x-1,y-1| x,y-1 |x+1,y-1| 
+-------+-------+-------+-------+ 
|  | x-1,y | x,y | x+1,y | 
+-------+-------+-------+-------+ 
|  |x-1,y+1| x,y+1 |x+1,y+1| 
+-------+-------+-------+-------+ 

암이, 같은 단지 더 많은 것이다. 그것들은 점검하고 목록에 추가하기 위해 더 인접 해있을 것입니다.

내가하는 것보다 더 나은 요구 사항을 이해하시기 바랍니다.

---

몇 가지 제안 :

• 당신은지도에서 위치를 나타내는 유형을 사용하는 고려할 수 있습니다. 행과 열 변수의 쌍을 많이 사용하고 있기 때문에, 그 유형을 가지고있는 것이 맞습니다 ... 저는 단지 Tuple<short, short>을 사용하고 있습니다 만 더 잘할 수 있습니다.

• 인접 항목이 이전 위치가 아닌지 확인하고이를 목록에 추가하는 논리를 캡슐화 할 수 있습니다.이점은 코드를 더 읽기 쉽게 만들고 오류가 발생하지 않게 만듭니다 (예 : 실수로 인접한 하나를 확인하지 않고 다른 하나를 추가하지 않는 것, 이는 복사 & 붙여 넣기에서 빠질 수 있음).

---

부록 : I 출력이 문자열 것 같아요, 당신은 StringBuilder로를 구축 할 수 있습니다. 추가하는 캐릭터는 선택한 인접 항목에 따라 다릅니다. 인접한 좌표와 문자를 선택하는 경우 사용하는 문자를 모두 보유하는 구조 일 수 있습니다. 또는 콘솔에 경로를 그려야합니까? 그것은 완전히 다른 무언가이기 때문입니다.