判斷矩陣元素相連——CSharp陣列

阿新 • • 發佈：2019-01-12

題目如下：

題目是這樣的，判斷一個圖是不是連通圖。

一個矩陣裡邊只有0和1組成。如果矩陣裡，1周圍的8個位置，還有1，那麼這2個1就算聯通的。
如果這個圖裡所有的1都能互相聯通那麼，就這個矩陣就是聯通的，否則就是不聯通的。

用演算法判斷一個矩陣是不是聯通的。

程式碼如下：

    class Matrix
    {

        public int[,] createMatrix(int m, int n)
        {
            Random rd = new Random();
            int[,] matrix = new int[m, n];
            for (int i = 0; i < m; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    matrix[i, j] = rd.Next(0, 2);
                }
            }
            return matrix;
        }

        public List<int[]> searchElementsOut(int[,] matrix)
        {
            List<int[]> elements = new List<int[]>();
            for (int i = 0; i < matrix.GetLength(0); i++)
            {
                for (int j = 0; j < matrix.GetLength(1); j++)
                {
                    if (matrix[i, j] == 1)
                    {
                        int[] ele = new int[2];
                        ele[0] = i;
                        ele[1] = j;
                        elements.Add(ele);
                    }
                }
            }
            return elements;
        }

        public List<int[]> searchElementLink(int[,] matrix, int Em, int En)
        {
            List<int[]> elements = new List<int[]>();
            if (Em == 0 && En == 0)
            {
                if (matrix[Em + 1, En] == 1)
                {
                    int[] temp = { Em + 1, En };
                    elements.Add(temp);
                }
                if (matrix[Em, En + 1] == 1)
                {
                    int[] temp = { Em, En + 1 };
                    elements.Add(temp);
                }
                if (matrix[Em + 1, En + 1] == 1)
                {
                    int[] temp = { Em + 1, En + 1 };
                    elements.Add(temp);
                }
            }
            else if (Em == 0 && En > 0 && En < matrix.GetLength(1) - 1)
            {
                if (matrix[Em, En - 1] == 1)
                {
                    int[] temp = { Em, En - 1 };
                    elements.Add(temp);
                }
                if (matrix[Em, En + 1] == 1)
                {
                    int[] temp = { Em, En + 1 };
                    elements.Add(temp);
                }
                if (matrix[Em + 1, En - 1] == 1)
                {
                    int[] temp = { Em + 1, En - 1 };
                    elements.Add(temp);
                }
                if (matrix[Em + 1, En] == 1)
                {
                    int[] temp = { Em + 1, En };
                    elements.Add(temp);
                }
                if (matrix[Em + 1, En + 1] == 1)
                {
                    int[] temp = { Em + 1, En + 1 };
                    elements.Add(temp);
                }
            }
            else if (Em == 0 && En == matrix.GetLength(1) - 1)
            {
                if (matrix[Em, En - 1] == 1)
                {
                    int[] temp = { Em, En - 1 };
                    elements.Add(temp);
                }
                if (matrix[Em + 1, En - 1] == 1)
                {
                    int[] temp = { Em + 1, En - 1 };
                    elements.Add(temp);
                }
                if (matrix[Em + 1, En] == 1)
                {
                    int[] temp = { Em + 1, En };
                    elements.Add(temp);
                }
            }
            else if (Em > 0 && Em < matrix.GetLength(0) - 1 && En == 0)
            {
                if (matrix[Em - 1, En] == 1)
                {
                    int[] temp = { Em - 1, En };
                    elements.Add(temp);
                }
                if (matrix[Em - 1, En + 1] == 1)
                {
                    int[] temp = { Em - 1, En + 1 };
                    elements.Add(temp);
                }
                if (matrix[Em, En + 1] == 1)
                {
                    int[] temp = { Em, En + 1 };
                    elements.Add(temp);
                }
                if (matrix[Em + 1, En] == 1)
                {
                    int[] temp = { Em + 1, En };
                    elements.Add(temp);
                }
                if (matrix[Em + 1, En + 1] == 1)
                {
                    int[] temp = { Em + 1, En + 1 };
                    elements.Add(temp);
                }
            }
            else if (Em > 0 && Em < matrix.GetLength(0) - 1 && En == matrix.GetLength(1) - 1)
            {
                if (matrix[Em - 1, En - 1] == 1)
                {
                    int[] temp = { Em - 1, En - 1 };
                    elements.Add(temp);
                }
                if (matrix[Em - 1, En] == 1)
                {
                    int[] temp = { Em - 1, En };
                    elements.Add(temp);
                }
                if (matrix[Em, En - 1] == 1)
                {
                    int[] temp = { Em, En - 1 };
                    elements.Add(temp);
                }
                if (matrix[Em + 1, En - 1] == 1)
                {
                    int[] temp = { Em + 1, En - 1 };
                    elements.Add(temp);
                }
                if (matrix[Em + 1, En] == 1)
                {
                    int[] temp = { Em + 1, En };
                    elements.Add(temp);
                }
            }
            else if (Em == matrix.GetLength(0) - 1 && En == 0)
            {
                if (matrix[Em - 1, En] == 1)
                {
                    int[] temp = { Em - 1, En };
                    elements.Add(temp);
                }
                if (matrix[Em - 1, En + 1] == 1)
                {
                    int[] temp = { Em - 1, En + 1 };
                    elements.Add(temp);
                }
                if (matrix[Em, En + 1] == 1)
                {
                    int[] temp = { Em, En + 1 };
                    elements.Add(temp);
                }
            }
            else if (Em == matrix.GetLength(0) - 1 && En > 0 && En < matrix.GetLength(1) - 1)
            {
                if (matrix[Em - 1, En - 1] == 1)
                {
                    int[] temp = { Em - 1, En - 1 };
                    elements.Add(temp);
                }
                if (matrix[Em - 1, En] == 1)
                {
                    int[] temp = { Em - 1, En };
                    elements.Add(temp);
                }
                if (matrix[Em - 1, En + 1] == 1)
                {
                    int[] temp = { Em - 1, En + 1 };
                    elements.Add(temp);
                }
                if (matrix[Em, En - 1] == 1)
                {
                    int[] temp = { Em, En - 1 };
                    elements.Add(temp);
                }
                if (matrix[Em, En + 1] == 1)
                {
                    int[] temp = { Em, En + 1 };
                    elements.Add(temp);
                }
            }
            else if (Em == matrix.GetLength(0) - 1 && En == matrix.GetLength(1) - 1)
            {
                if (matrix[Em - 1, En - 1] == 1)
                {
                    int[] temp = { Em - 1, En - 1 };
                    elements.Add(temp);
                }
                if (matrix[Em - 1, En] == 1)
                {
                    int[] temp = { Em - 1, En };
                    elements.Add(temp);
                }
                if (matrix[Em, En - 1] == 1)
                {
                    int[] temp = { Em, En - 1 };
                    elements.Add(temp);
                }
            }
            else if (Em > 0 && Em < matrix.GetLength(0) - 1 && En > 0 && En < matrix.GetLength(1) - 1)
            {
                if (matrix[Em - 1, En - 1] == 1)
                {
                    int[] temp = { Em - 1, En - 1 };
                    elements.Add(temp);
                }
                if (matrix[Em - 1, En] == 1)
                {
                    int[] temp = { Em - 1, En };
                    elements.Add(temp);
                }
                if (matrix[Em - 1, En + 1] == 1)
                {
                    int[] temp = { Em - 1, En + 1 };
                    elements.Add(temp);
                }
                if (matrix[Em, En - 1] == 1)
                {
                    int[] temp = { Em, En - 1 };
                    elements.Add(temp);
                }
                if (matrix[Em, En + 1] == 1)
                {
                    int[] temp = { Em, En + 1 };
                    elements.Add(temp);
                }
                if (matrix[Em + 1, En - 1] == 1)
                {
                    int[] temp = { Em + 1, En - 1 };
                    elements.Add(temp);
                }
                if (matrix[Em + 1, En] == 1)
                {
                    int[] temp = { Em + 1, En };
                    elements.Add(temp);
                }
                if (matrix[Em + 1, En + 1] == 1)
                {
                    int[] temp = { Em + 1, En + 1 };
                    elements.Add(temp);
                }
            }
            return elements;
        }

        public void searchElementsLink(int[,] matrix, int Em, int En, ref List<int[]> elementsPeri, ref List<int[]> elements)
        {
            List<int[]> elementsPeriT = new List<int[]>();
            List<int[]> elementsPeriTs = new List<int[]>();
            List<int[]> elementsPeriTt = new List<int[]>();
            if (elementsPeri.Count != 0)
            {
                foreach (int[] per in elementsPeri)
                {
                    if (!isContains(elements, per))
                    {
                        elements.Add(per);
                    }
                    elementsPeriTt = searchElementLink(matrix, per[0], per[1]);
                    elementsPeriTs.AddRange(elementsPeriTt);
                }
            }
            if (elementsPeriTs.Count != 0)
            {
                foreach (int[] per in elementsPeriTs)
                {
                    if (!isContains(elements, per))
                    {
                        elementsPeriT.Add(per);
                    }
                }
            }
            elementsPeri = elementsPeriT;
        }

        public bool isContains(List<int[]> list, int[] tmp)
        {
            bool result = false;
            foreach (int[] l in list)
            {
                if (l[0] == tmp[0] && l[1] == tmp[1])
                {
                    result = true; break;
                }
            }
            return result;
        }

        public bool isLink(int[,] matrix, int Em1, int En1, int Em2, int En2)
        {
            bool islink = false;
            List<int[]> elements = new List<int[]>();
            List<int[]> element1 = searchElementLink(matrix, Em1, En1);
            while (element1.Count != 0)
            {
                searchElementsLink(matrix, Em1, En1, ref element1, ref elements);
            }
            int[] E2 = { Em2, En2 };
            if (isContains(elements, E2))
            {
                islink = true;
            }
            return islink;
        }

        public void dowork(int m, int n)
        {
            Console.WriteLine("隨機陣列如下：");
            int[,] matrix = createMatrix(m, n);
            for (int i = 0; i < m; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    Console.Write(matrix[i, j].ToString() + "  ");
                }
                Console.WriteLine();
            }

            List<int[]> elementsout = new List<int[]>();
            elementsout = searchElementsOut(matrix);

            int[] ele = new int[2];
            for (int i = 0; i < m; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    if (matrix[i, j] == 1)
                    {
                        ele[0] = i;
                        ele[1] = j; break;
                    }
                }
            }

            bool islink = true;
            foreach (int[] e in elementsout)
            {
                if (!isLink(matrix, e[0], e[1], ele[0], ele[1]))
                {
                    islink = false; break;
                }
            }

            Console.WriteLine(islink.ToString());


        }

    }

        static void Main(string[] args)
        {
            Matrix mat = new Matrix();
            mat.dowork(15, 15);
            Console.ReadKey();
        }

簡單解釋一下程式碼。

createMatrix(m,n)是建立一個m行n列矩陣模型陣列；

searchElementsOut(matrix)是搜尋出矩陣中的所有的為1的元素；

searchElementLink(matrix,Em,En)是搜尋出元素matrix[Em,En]周邊為1的元素；

searchElementsLink(matrix,Em,En,ref elementsPeri,elements)在matrix矩陣中搜索與元素matrix[Em,En]所有相關聯的元素；

isContains(list,tmp)判斷陣列集list是否包含陣列；

dowork(m,n)方法體；

結果如下：

當m值和n值偏大的情況下，結果為False的居多。

判斷矩陣元素相連——CSharp陣列

題目如下：題目是這樣的，判斷一個圖是不是連通圖。一個矩陣裡邊只有0和1組成。如果矩陣裡，1周圍的8個位置，還有1，那麼這2個1就算聯通的。如果這個圖裡所有的1都能互相聯通那麼，就這個矩陣就是聯通的，否則就是不聯通的。用演算法判斷一個矩陣是不是聯通的。程式碼如下：

js判斷一個元素是否在陣列中

js中存在一個數組，如何判斷一個元素是否存在於這個陣列中呢，首先是通過迴圈的辦法判斷，程式碼如下：var arr = ['a','s','d','f']; console.info(isInArray(arr,'a'));//迴圈的方式 /** * 使用迴圈的方式判斷一個

jquery 判斷元素是否在陣列內

js 方法： var arr = ["a", "b", "c"]; // js arr.indexOf("c") var result1 = arr.indexOf("c"); //返回index為2,失敗返回-1 jquery 方法： var arr = ["a", "b", "c

判斷某個元素是否存在於某個 js 陣列中

1.正則表示式 Array.prototype.in_array=function(e){ var r=new RegExp(','+e+','); return (r.test(','+th

陣列_習題：編寫一個4*4矩陣元素對角線之和的程式

# include <stdio.h>int main(void){ int a[4][4] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}; int i, j, sum1, sum2;//定義sum1,sum2,分別存放兩條對線元素的和； sum1=sum

JS判斷元素是否在陣列中

方法一：indexOf() var arr = new Array('a', 'b','c'); var index = arr.indexOf('a');//index為0 注：inde

在JSP使用EL中判斷指定元素是否存在於指定集合中

element span cti ems 頁面指定元素 jsp 指定 col 在JSP使用EL中判斷指定元素是否存在於指定集合中 1、問題描述　　在JSP頁面中使用EL表達式判斷一個指定元素是否存在於指定集合中？ 2、問題解決　　eg：指定集合：collection：

怎麽使用jquery判斷一個元素是否含有一個指定的類（class）

() pla jquer java 例子 add red tro lan 在jQuery中可以使用2種方法來判斷一個元素是否包含一個確定的類(class)。兩種方法有著相同的功能。2種方法如下： 1. is(‘.classname’) 2.

python中如何不區分大小寫的判斷一個元素是否在一個列表中

拒絕結果大小寫 over 用戶 ima image -1 技術分享 python中判斷某一個元素是否在一個列表中，可以使用關鍵字in 和 not in. 示例如下：如果需要輸出相應的信息，可以搭配使用if語句，這裏不贅述。 ---------------------

jQuery判斷當前元素是第幾個元素&獲取第N個元素

jquer ont query font href 點擊我們 div fun jQuery判斷當前元素是第幾個元素&獲取第N個元素假設有下面這樣一段HTML代碼： <ul> <li>jQuery判斷當前元素是第幾個元素示例&

jQuery-----1)創建新標簽,,2)判斷某個元素是否包含某個文字

on() this size body pre ood -- appendto rep 1)創建新標簽方法一: var ele_input=$(‘<input/>‘) ele_input.val(‘你是最棒的‘) ele_input.attr(‘class

判斷一個元素有沒有條件

元素沒有 else right mat func pan logs cti function change(){ if ($(‘.clickImg‘).attr(‘src‘).match(‘left‘)) { $(

expected_conditions判斷頁面元素

ted 需要 frame 不可 enc bili tro 這樣的 body expected_condtions提供了16種判斷頁面元素的方法： 1.title_is:判斷當前頁面的title是否完全等於預期字符串，返回布爾值 2.title_contains:判斷當前頁面

00083_判斷集合元素唯一的原理

規則 list ash 新元素相同結果 code array contain 1、ArrayList的contains方法判斷元素是否重復原理　　ArrayList的contains方法會使用調用方法時，傳入的元素的equals方法依次與集合中的舊元素所比較，從而根據

MATLAB基礎知識——1.4矩陣元素的引用

運算符子矩陣知識 str res 說明向量列存儲 font 矩陣元素的引用方式（1）通過下標引用矩陣元素，下標必須為正整數，且用圓括號括起來。（2）通過序號來引用，在MATLAB中矩陣元素按列存儲。序號與下標是一一對應的，以m*n的矩陣A為例，矩陣A（i，j）的

jQuery如何判斷input元素是否獲得焦點(點擊編輯時)

() 監聽 clas ima func 處理方法 IV col input 問題提出如果你要判斷input元素是否獲得焦點，或者是否處在活動編輯狀態，使用jQuery的 hasFocus() 方法或 is(‘:focus‘) 方法貌似都無效！搜索網上給出的辦法，幾乎凈是采

JQuery判斷一個元素是否顯示,隱藏

spa 顯示 true string hidden 判斷 ble visible dde $("#id").is(‘:visible‘);顯示為true $("#id").is(‘:hidden‘);隱藏為trueJQuery判斷一個元素是否顯示,隱藏

從javascript判斷一個物件是否為陣列中學習js語法

1，真正的陣列的判斷方法 javascript中最簡單的宣告陣列方法為： var a = []; 判斷是否為陣列的最直接的方法為： a instanceof Array //true a .constructor == Array //true 這裡涉及到一個i

leetcode693+判斷二進位制是否相連不同數字

https://leetcode.com/problems/binary-number-with-alternating-bits/description/ class Solution { public: bool hasAlternatingBits(int n) {

每日一題之LeetCode移除元素刪除有序陣列重複元素

這兩道題若是不使用官方題解的雙指標做法，就會涉及到淺複製，深複製的問題，可參考如下https://blog.csdn.net/qq_32907349/article/details/52190796 。其中，此題將要使用深複製，但這會違背題意中的不開闢新的記憶體空間。 1.移除元素class Soluti

判斷矩陣元素相連——CSharp陣列

相關推薦