一種分割地圖的並行分割演算法。

来源:http://www.cnblogs.com/hccccc/archive/2017/11/13/7828501.html
-Advertisement-
Play Games

7個國家首都與中國的首都連線，線段的交於中國地圖上，記為7個點，這幾個點彼此互不影響，互不重合，按照各自國家所占的貿易比例，同時進行分割地圖。 ...


問題：7個國家首都與中國的首都連線，線段的交於中國地圖上，記為7個點，這幾個點彼此互不影響，互不重合，按照各自國家所占的貿易比例，同時進行分割地圖。

思路：利用深度，廣度遍歷均可。

  1 package hccc01;
  2 
  3 import java.awt.image.BufferedImage;
  4 import java.io.File;
  5 import java.io.IOException;
  6 import java.util.ArrayList;
  7 import java.util.Map;
  8 
  9 import javax.imageio.ImageIO;
 10 
 11 public class tree_map {
 12     static ArrayList<String> list = tree_map1.getList();
 13     static Map<String, Integer> map = tree_map1.getMap();
 14     // 俄羅斯(255, 175, 175) 149697 2.7% 4686 173577
 15     static ArrayList<String> A = new ArrayList<String>() {
 16         {
 17             add("351,210");
 18         }
 19     };
 20     static int n_a = 0;
 21     // 土耳其(255, 255, 0) 51664 0.2% 347
 22     static ArrayList<String> B = new ArrayList<String>() {
 23         {
 24             add("279,299");
 25         }
 26     };
 27     static int n_b = 0;
 28 
 29     // 美國(255, 200, 0) 2689245 46.4% 80539
 30     static ArrayList<String> C = new ArrayList<String>() {
 31         {
 32             add("244,317");
 33         }
 34     };
 35     static int n_c = 0;
 36 
 37     // 南韓(0, 255, 0) 778850 13.5% 23432
 38     static ArrayList<String> D = new ArrayList<String>() {
 39         {
 40             add("784,322");
 41         }
 42     };
 43     static int n_d = 0;
 44 
 45     // 巴西(0, 255, 255) 1003099 17.3% 30028
 46     static ArrayList<String> E = new ArrayList<String>() {
 47         {
 48             add("341,465");
 49         }
 50     };
 51     static int n_e = 0;
 52     // 澳大利亞(0, 0, 255) 1132923 19.6% 34021
 53     static ArrayList<String> F = new ArrayList<String>() {
 54         {
 55             add("816,482");
 56         }
 57     };
 58     static int n_f = 0;
 59 
 60     // 坦桑利亞(255, 0, 255) 11501 0.3% 520
 61     static ArrayList<String> G = new ArrayList<String>() {
 62         {
 63             add("459,512");
 64         }
 65     };
 66     static int n_g = 0;
 67 
 68     public static void main(String[] args) {
 69         int n = 0;
 70         for (; n < 60338; n++) {
 71             // A點擴散
 72             aSpread(n);
 73             // B點擴散
 74             bSpread(n);
 75             cSpread(n);
 76             dSpread(n);
 77             eSpread(n);
 78             fSpread(n);
 79             gSpread(n);
 80         }
 81 
 82         // 擴散生成圖片
 83         create();
 84         // for (String in : map.keySet()) {
 85         // // map.keySet()返回的是所有key的值
 86         // Integer str = map.get(in);// 得到每個key多對用value的值
 87         // if (-65536==(str)) {
 88         // System.out.println(str);
 89         // }
 90         // }
 91         System.out.print("over");
 92     }
 93 
 94     private static void gSpread(int n) {
 95         if (n_g < 500) {
 96             int pixel = 0;
 97             int Xg = Integer.parseInt((G.get(n).split(","))[0]);
 98             int Yg = Integer.parseInt((G.get(n).split(","))[1]);
 99             String G1 = (Xg + 1) + "" + "," + Yg + "";
100             String G2 = Xg + "" + "," + (Yg + 1) + "";
101             String G3 = (Xg - 1) + "" + "," + Yg + "";
102             String G4 = Xg + "" + "," + (Yg - 1) + "";
103             String G5 = (Xg + 1) + "" + "," + (Yg + 1) + "";
104             String G6 = (Xg + 1) + "" + "," + (Yg - 1) + "";
105             String G7 = Xg + "" + "," + Yg + "";
106             String G8 = (Xg - 1) + "" + "," + (Yg - 1) + "";
107             String G9 = (Xg - 1) + "" + "," + (Yg + 1) + "";
108             // 資源池包含G點，則進行染色，否則不做處理
109             if (list.contains(G1)) {
110                 pixel = tree_map1.getPixel(255, 0, 255);
111                 map.put(G1, pixel);
112                 list.remove(G1);
113                 G.add(G1);
114                 n_g += 1;
115             }
116             if (list.contains(G2)) {
117                 pixel = tree_map1.getPixel(255, 0, 255);
118                 map.put(G2, pixel);
119                 list.remove(G2);
120                 G.add(G2);
121                 n_g += 1;
122             }
123             if (list.contains(G3)) {
124                 pixel = tree_map1.getPixel(255, 0, 255);
125                 map.put(G3, pixel);
126                 list.remove(G3);
127                 G.add(G3);
128                 n_g += 1;
129             }
130             if (list.contains(G4)) {
131                 pixel = tree_map1.getPixel(255, 0, 255);
132                 map.put(G4, pixel);
133                 list.remove(G4);
134                 G.add(G4);
135                 n_g += 1;
136             }
137             if (list.contains(G5)) {
138                 pixel = tree_map1.getPixel(255, 0, 255);
139                 map.put(G5, pixel);
140                 list.remove(G5);
141                 G.add(G5);
142                 n_g += 1;
143             }
144             if (list.contains(G6)) {
145                 pixel = tree_map1.getPixel(255, 0, 255);
146                 map.put(G6, pixel);
147                 list.remove(G6);
148                 G.add(G6);
149                 n_g += 1;
150             }
151             if (list.contains(G7)) {
152                 pixel = tree_map1.getPixel(255, 0, 255);
153                 map.put(G7, pixel);
154                 list.remove(G7);
155                 G.add(G7);
156                 n_g += 1;
157             }
158             if (list.contains(G8)) {
159                 pixel = tree_map1.getPixel(255, 0, 255);
160                 map.put(G8, pixel);
161                 list.remove(G8);
162                 G.add(G8);
163                 n_g += 1;
164             }
165             if (list.contains(G9)) {
166                 pixel = tree_map1.getPixel(255, 0, 255);
167                 map.put(G9, pixel);
168                 list.remove(G9);
169                 G.add(G9);
170                 n_g += 1;
171             }
172         }
173     }
174 
175     private static void fSpread(int n) {
176         if (n_f < 40897) {
177             int pixel = 0;
178             int Xf = Integer.parseInt((F.get(n).split(","))[0]);
179             int Yf = Integer.parseInt((F.get(n).split(","))[1]);
180             String F1 = (Xf + 1) + "" + "," + Yf + "";
181             String F2 = Xf + "" + "," + (Yf + 1) + "";
182             String F3 = (Xf - 1) + "" + "," + Yf + "";
183             String F4 = Xf + "" + "," + (Yf - 1) + "";
184             String F5 = (Xf + 1) + "" + "," + (Yf + 1) + "";
185             String F6 = (Xf + 1) + "" + "," + (Yf - 1) + "";
186             String F7 = Xf + "" + "," + Yf + "";
187             String F8 = (Xf - 1) + "" + "," + (Yf - 1) + "";
188             String F9 = (Xf - 1) + "" + "," + (Yf + 1) + "";
189             // 資源池包含F點，則進行染色，否則不做處理
190             if (list.contains(F1)) {
191                 pixel = tree_map1.getPixel(0, 0, 255);
192                 map.put(F1, pixel);
193                 list.remove(F1);
194                 F.add(F1);
195                 n_f += 1;
196             }
197             if (list.contains(F2)) {
198                 pixel = tree_map1.getPixel(0, 0, 255);
199                 map.put(F2, pixel);
200                 list.remove(F2);
201                 F.add(F2);
202                 n_f += 1;
203             }
204             if (list.contains(F3)) {
205                 pixel = tree_map1.getPixel(0, 0, 255);
206                 map.put(F3, pixel);
207                 list.remove(F3);
208                 F.add(F3);
209                 n_f += 1;
210             }
211             if (list.contains(F4)) {
212                 pixel = tree_map1.getPixel(0, 0, 255);
213                 map.put(F4, pixel);
214                 list.remove(F4);
215                 F.add(F4);
216                 n_f += 1;
217             }
218             if (list.contains(F5)) {
219                 pixel = tree_map1.getPixel(0, 0, 255);
220                 map.put(F5, pixel);
221                 list.remove(F5);
222                 F.add(F5);
223                 n_f += 1;
224             }
225             if (list.contains(F6)) {
226                 pixel = tree_map1.getPixel(0, 0, 255);
227                 map.put(F6, pixel);
228                 list.remove(F6);
229                 F.add(F6);
230                 n_f += 1;
231             }
232             if (list.contains(F7)) {
233                 pixel = tree_map1.getPixel(0, 0, 255);
234                 map.put(F7, pixel);
235                 list.remove(F7);
236                 F.add(F7);
237                 n_f += 1;
238             }
239             if (list.contains(F8)) {
240                 pixel = tree_map1.getPixel(0, 0, 255);
241                 map.put(F8, pixel);
242                 list.remove(F8);
243                 F.add(F8);
244                 n_f += 1;
245             }
246             if (list.contains(F9)) {
247                 pixel = tree_map1.getPixel(0, 0, 255);
248                 map.put(F9, pixel);
249                 list.remove(F9);
250                 F.add(F9);
251                 n_f += 1;
252             }
253         }
254     }
255 
256     private static void eSpread(int n) {
257         if (n_e < 40876) {
258             int pixel = 0;
259             int Xe = Integer.parseInt((E.get(n).split(","))[0]);
260             int Ye = Integer.parseInt((E.get(n).split(","))[1]);
261             String E1 = (Xe + 1) + "" + "," + Ye + "";
262             String E2 = Xe + "" + "," + (Ye + 1) + "";
263             String E3 = (Xe - 1) + "" + "," + Ye + "";
264             String E4 = Xe + "" + "," + (Ye - 1) + "";
265             String E5 = (Xe + 1) + "" + "," + (Ye + 1) + "";
266             String E6 = (Xe + 1) + "" + "," + (Ye - 1) + "";
267             String E7 = Xe + "" + "," + Ye + "";
268             String E8 = (Xe - 1) + "" + "," + (Ye - 1) + "";
269             String E9 = (Xe - 1) + "" + "," + (Ye + 1) + "";
270             // 資源池包含E點，則進行染色，否則不做處理
271             if (list.contains(E1)) {
272                 pixel = tree_map1.getPixel(0, 255, 255);
273                 map.put(E1, pixel);
274                 list.remove(E1);
275                 E.add(E1);
276                 n_e += 1;
277             }
278             if (list.contains(E2)) {
279                 pixel = tree_map1.getPixel(0, 255, 255);
280                 map.put(E2, pixel);
281                 list.remove(E2);
282                 E.add(E2);
283                 n_e += 1;
284             }
285             if (list.contains(E3)) {
286                 pixel = tree_map1.getPixel(0, 255, 255);
287                 map.put(E3, pixel);
288                 list.remove(E3);
289                 E.add(E3);
290                 n_e += 1;
291             }
292             if (list.contains(E4)) {
293                 pixel = tree_map1.getPixel(0, 255, 255);
294                 map.put(E4, pixel);
295                 list.remove(E4);
296                 E.add(E4);
297                 n_e += 1;
298             }
299             if (list.contains(E5)) {
300                 pixel = tree_map1.getPixel(0, 255, 255);
301                 map.put(E5, pixel);
302                 list.remove(E5);
303                 E.add(E5);
304                 n_e += 1;
305             }
306             if (list.contains(E6)) {
307                 pixel = tree_map1.getPixel(0, 255, 255);
308                 map.put(E6, pixel);
309                 list.remove(E6);
310                 E.add(E6);
311                 n_e += 1;
312             }
313             if (list.contains(E7)) {
314                 pixel = tree_map1.getPixel(0, 255, 255);
315                 map.put(E7, pixel);
316                 list.remove(E7);
317                 E.add(E7);
318                 n_e += 1;
319             }
320             if (list.contains(E8)) {
321                 pixel = tree_map1.getPixel(0, 255, 255);
322                 map.put(E8, pixel);
323                 list.remove(E8);
324                 E.add(E8);
325                 n_e += 1;
326             }
327             if (list.contains(E9)) {
328                 pixel = tree_map1.getPixel(0, 255, 255);
329                 map.put(E9, pixel);
330                 list.remove(E9);
331                 E.add(E9);
332                 n_e += 1;
333             }
334         }
335     }
336 
337     private static void dSpread(int n) {
338         if (n_d < 45204) {
339             int pixel = 0;
340             int Xd = Integer.parseInt((D.get(n).split(","))[0]);
341             int Yd = Integer.parseInt((D.get(n).split(","))[1]);
342             String D1 = (Xd + 1) + "" + "," + Yd + "";
343             String D2 = Xd + "" + "," + (Yd + 1) + "";
344             String D3 = (Xd - 1) + "" + "," + Yd + "";
345             String D4 = Xd + "" + "," + (Yd - 1) + "";
346             String D5 = (Xd + 1) + "" + "," + (Yd + 1) + "";
347             String D6 = (Xd + 1) + "" + "," + (Yd - 1) + "";
348             String D7 = Xd + "" + "," + Yd + "";
349             String D8 = (Xd - 1) + "" + "," + (Yd - 1) + "";
350             String D9 = (Xd - 1) + "" + "," + (Yd + 1) + "";
351             // 資源池包含D點，則進行染色，否則不做處理
352             if (list.contains(D1)) {
353                 pixel = tree_map1.getPixel(0, 255, 0);
354                 map.put(D1, pixel);
355                 list.remove(D1);
356                 D.add(D1);
357                 n_d += 1;
358             }
359             if (list.contains(D2)) {
360                 pixel = tree_map1.getPixel(0, 255, 0);
361                 map.put(D2, pixel);
362                 list.remove(D2);
363                 D.add(D2);
364                 n_d += 1;
365             }
366             if (list.contains(D3)) {
367                 pixel = tree_map1.getPixel(0, 255, 0);
368                 map.put(D3, pixel);
369                 list.remove(D3);
370                 D.add(D3);
371                 n_d += 1;
372             }
373             if (list.contains(D4)) {
374                 pixel = tree_map1.getPixel(0, 255, 0);
375                 map.put(D4, pixel);
376                 list.remove(D4);
377                 D.add(D4);
378                 n_d += 1;
379             }
380             if (list.contains(D5)) {
381                 pixel = tree_map1.getPixel(0, 255, 0);
382                 map.put(D5, pixel);
383                 list.remove(D5);
384                 D.add(D5);
385                 n_d += 1;
386             }
387             if (list.contains(D6)) {
388                 pixel = tree_map1.getPixel(0, 255, 0);
389                 map.put(D6, pixel);
390
您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • java數據結構面試問題—快慢指針問題
    上次我們學習了環形鏈表的數據結構，那麼接下來我們來一起看看下麵的問題， 判斷一個單向鏈表是否是環形鏈表？ 看到這個問題，有人就提出了進行遍歷鏈表，記住第一元素，當我們遍歷後元素再次出現則是說明是環形鏈表，如果沒有這是一個單向非環形鏈表。 我們來分析下上述的解決方法，我們分析這個程式的時間複雜度則是O ...
  • 使用QNetworkAccessManager實現Qt的FTP下載服務
    使用QNetworkAccessManager實現Qt的FTP下載操作，此外包含以下功能：（1）添加下載超時操作；（2）大文件分割下載。 附加C++實現命令行輸出進度條實現代碼。 ...
  • Python如何將RGB圖像轉換為Pytho灰度圖像？
    問題： 我正嘗試使用matplotlib讀取RGB圖像並將其轉換為灰度。在matlab中，我使用這個： 1 img = rgb2gray(imread('image.png')); 1 img = rgb2gray(imread('image.png')); 1 img = rgb2gray(imr ...
  • 如何在Django模板中包含圖像文件？
    我是Django的新手，我試圖通過我正在開發的一個簡單的項目“dubliners”和一個名為“book”的應用程式來學習它。目錄結構如下所示： 1 2 dubliners/book/ [includes models.py, views.py, etc.] dubliners/templates/b ...
  • [深度學習]實現一個博弈型的AI，從五子棋開始（1）
    最近AlphaGo Zero的發佈，深度學習又火了一把，小伙伴們按捺不住內心的躁動，要搞一個游戲AI，好吧，那就從規則簡單、老少皆宜的五子棋開始講起。要做AI，得現有場景，所以本文先實現一個五子棋的邏輯。 ...
  • Python中import機制
    Python語言中import的使用很簡單，直接使用import module_name語句導入即可。這裡我主要寫一下"import"的本質。 Python官方定義：Python code in one module gains access to the code in another modul ...
  • python中文分詞，使用結巴分詞對python進行分詞
    在採集美女站時,需要對關鍵詞進行分詞,最終採用的是python的結巴分詞方法. 中文分詞是中文文本處理的一個基礎性工作，結巴分詞利用進行中文分詞。其基本實現原理有三點： 安裝（Linux環境） 下載工具包，解壓後進入目錄下，運行：python setup.py install 模式 介面 組件只提供 ...
  • os和sys模塊的區別及其常用方法總結
    官方解釋：os： This module provides a portable way of using operating system dependent functionality. 翻譯：提供一種方便的使用操作系統函數的方法。sys：This module provides access ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類