مسئله فروشنده دوره‌گرد (به انگلیسی: Travelling salesman problem ، به‌اختصار: TSP )

مسئله فروشنده دوره‌گرد (به انگلیسی: Travelling salesman problem ، به‌اختصار: TSP )


http://upload.wikimedia.org/wikipedi...x-Salesman.PNG

اگر فروشنده دوره‌گرد از نقطه A شروع کند و فواصل بین نقاط مشخص باشد، کوتاه‌تربن مسیر که از تمام نقاط یکبار بازدید می‌کند و به A بازمی‌گردد کدام است؟
........
مسئله فروشنده دوره گرد TSP یکی از مسائل مهم در زمره تئوری پیچیدگی محاسباتی الگوریتم ها می باشد که در گروه NP-Hard قرار می گیرد این مسئله اولین بار توسط دو دانشمند به نام های 1- هامیلتون ایرلندی و 2- کیرکمن بریتانیایی مطرح شد . معمولا بحث در خصوص این تئوری در مطالب اولیه دروس ریاضیات دانشجویان ریاضی ارائه می شود و در دروسی نظیر تئوری گراف می توانید مطالب مشابه را نیز بدست آورید .

طرح مسئله
تعدادی شهر داریم و هزینه (مسافت) مسافرت به هر یک از آنها مشخص است به دنبال کم هزینه ترین مسیر هستیم بطوریکه از همه شهرها فقط یکبار عیور کنیم و مجددا به محل شروع بازگردیم

پیچیدگی محاسباتی الگوریتم فروشنده دوره گرد
این الگوریتم بطور مستقیم در مرتبه زمانی(!O(n حل می شود اما اگر به روش برنامه نویسی پویا برای حل آن استفاده کنیم مرتبه زمانی آن (O(n^2*2^n خواهد شد که جز مرتبه های نمایی است. باید توجه داشت علی رغم آنکه مرتبه نمایی مذکور زمان بسیار بدی است اما همچنان بسیار بهتر از مرتبه فاکتوریل می باشد .
..............
شبه کد الگوریتم فوق بصورت زیر است که در آن تعداد زیر مجموعه های یک مجموعه n عضوی 2 به توان n می باشد
و for اول یک ضریب n را نیز حاصل می شود که به ازای تمام شهرهای غیر مبدا می باشد و حاصل (n*(2^n را پدید می آورد
بنابراین برای جستجوی کمترین مقدار نیاز به یک عملیات خطی از مرتبه n داریم که در زمان فوق نیز ضرب می شود و در نهایت زمان (n^2)*(2^n) را برای این الگوریتم حاصل می کند

كد:
C({1},1) = 0 for (S=2 to n ) for All Subsets S subset of {1,2,3,...} of size S and containing 1 C(S,1) = & for All J member of S , J<>1 C ( S , J ) = min { C ( S - { J } , i ) + D i,J : i member of S , i <> J } return min j C ( {1 . . . n}, J ) + D J,1
.............
اين مسئله ، مسئله‌ای مشهور است که ابتدا در سده ۱۸ مسائل مربوط به آن توسط ویلیام همیلتون و توماس کرکمن مطرح شد و سپس در دهه ۱۹۳۰ شکل عمومی آن به وسیله ریاضیدانانی مثل کارل منگر از دانشگاه هاروارد و هاسلر ویتنی از دانشگاه پرینستون مورد مطالعه قرار گرفت.
شرح مسئله بدین شکل است:
تعدادی شهر داریم و هزینه رفتن مستقیم از یکی به دیگری را می‌دانیم. مطلوب است کم‌هزینه‌ترین مسیری که از یک شهر شروع شود و از تمامی شهرها دقیقاٌ یکبار عبور کند و به شهر شروع بازگردد.
تعداد کل راه‌حل‌ها برابر است با برای n>۲ که n تعداد شهرها است. در واقع این عدد برابر است با تعداد دورهای همیلتونی در یک گراف کامل با n رأس.

مسئله‌های مرتبط

مسئله معادل در نظریه گراف به این صورت است که یک گراف وزن‌دار کامل داریم که می‌خواهیم کم‌وزن‌ترین دور همیلتونی را پیدا کنیم.
مسئله تنگراه فروشنده دوره‌گرد (به انگلیسی: Bottleneck traveling salesman problem، به‌اختصار: bottleneck TSP ) مسئله‌ای بسیار کاربردی است که در یک گراف وزن‌دار کم‌وزن‌ترین دور همیلتونی را می‌خواهد که شامل سنگین‌ترین یال باشد.
تعمیم‌یافته مسئله فروشنده دوره‌گرد دارای ایالت‌هایی است که هر کدام حداقل یک شهر دارند و فروشنده باید از هر ایالت دقیقاٌ از یک شهر عبور کند. این مسئله به « مسئله سیاست‌مدار مسافر» نیز شهرت دارد.

الگوریتم‌ها
مسئله فروشنده دوره‌گرد جزء مسائل NP-hard است. راه‌های معمول مقابله با چنین مسائلی عبارتند از:
طراحی الگوریتم‌هایی برای پیدا کردن جواب‌های دقیق که استفاده از آنها فقط برای مسائل با اندازه کوچک صورت می‌گیرد.
استفاده از الگوریتم‌های مکاشفه‌ای که جواب‌هایی به‌دست می‌دهد که احتمالاٌ درست هستند.
پیدا کردن زیرمسئله‌هایی از مسئله یعنی تقسیم مسئله به مسئله‌های کوچکتر تا بشود از الگوریتم‌های مکاشفه‌ای بهتر و دقیق‌تری ارائه کرد.

الگوریتم‌های دقیق
سرراست ترین راه حل امتحان کردن تمامی جایگشت‌های ممکن برای پیدا کردن ارزان‌ترین مسیر است که چون تعداد جایگشت‌ها !n است، این راه حل غیرعملی می‌شود. با استفاده از برنامه‌نویسی پویا مسئله می‌تواند با مرتبه زمانی n22n حل شود. راه‌های دیگر استفاده از الگوریتم‌های انشعاب و تحدید برای ۴۰ تا ۶۰ شهر، استفاده از برنامه‌نویسی خطی برای کوچکتر از ۲۰۰ شهر و استفاده از روش برش-صفحه برای اندازه‌های بزرگ است.

الگوریتم‌های مکاشفه‌ای
الگوریتم‌های تقریبی متنوعی وجود دارند که خیلی سریع جواب‌های درست را با احتمال بالا به‌دست می‌دهند که می‌توان آنها را به صورت زیر دسته‌بندی کرد:
مکاشفه‌ای سازنده
بهبود تکراری
مبادله دوبه‌دو
مکاشفه‌ای k-opt
مکاشفه‌ای V-opt
بهبود تصادفی

ابتدا سايتهايي که کدهاي حل اين مسئله را از روش هاي متفاوت و زبانهاي مختلف ارائه کرده اند:

http://delphiforfun.org/programs/_de...er2010_bnr.gif

Source Code Library: Travelling Salesman Problem (TSP

Solving Travelling Salesman Problems Using Genetic Algorithms


Solution to Travelling Salesman Problem

روش ابتکاری ساخت و بهبود تور مسئله فروشنده دوره گرد نامتقارن


[DOWN]http://dl.azardl.com/sh/52613859810.pdf[/DOWN]

کد حل مساله فروشنده دوره گرد با الگوريتم ژنتيک


[DOWN]http://dl.azardl.com/sh/TSP.zip[/DOWN]

براي حل مسئله فروشنده دوره گرد با استفاده از شبکه هاپفیلد توصيه ميکنم اين مقالات را مطالعه بفرمائيد:

همچنين کدي با متلب در اين سايت قرار دارد:
كد:

کد:

---

http://en.pudn.com/downloads136/sourcecode/math/detail578369_en.html

---

يک کد هم از tsp در لینک های زیر آمده است .

[DOWN]http://dl.azardl.com/sh/Downloads43.rar[/DOWN]

حل مسأله tsp (فروشنده دوره گرد)با استفاده از شبکه عصبی هاپفیلد

و اين هم توضيحات کامل و برنامه همراه سورس سي پلاس پلاس

ارائه الگوریتم تركیبی مورچگان وژنتیك برای حل مسئله فروشنده دوره گرد

منبع: چهارمین کنفرانس بین المللی مهندسی صنایع - 1384

چکیده:
مساله فروشنده دوره گرد جزء مسائل مشهور و كلاسیك تحقیق در عملیات می باشد. بسیاری از فعالیت های
علمی را می توان به صورت مسئله فروشنده دوره گرد در آورد و سپس حل نمود. روشهای بهینه یابی موجود برای حل مسائل سخت (همچون مسئله فروشنده دوره گرد) بطور عمده شامل تعداد بسیار زیادی متغیر و محدودیت می باشند كه از كارایی عملی آنها در حل مسائل با ابعاد واقعی می كاهد بدین علت در دهه های اخیراستفاده ازالگوریتم های ابتكاری و فوق ابتكاری مورد توجه قرار گرفته است. در این بین الگوریتم های فوق ابتكاری بدلیل ساختار ساده وتوانایی هایی كه از خود نشان داده اند مورد استفاده محققین تحقیق در عملیات قرار گرفته است. در این تحقیق با تركیب دو الگوریتم كلونی مورچگان و الگوریتم ژنتیك سعی شده است الگوریتم تركیبی ساخته شود كه تور بهتری را برای مسئله فروشنده دوره گرد بدست آورد. پس از طراحی الگوریتم، تنظیم پارامترهای آن با حل مسائل متعدد صورت گرفته است و برای مقایسه روش پیشنهادی با روشهای الگوریتم ژنتیك و مورچگان برخی از مسائل حل شده است. نتایج بدست آمده نشان می دهد كه روش تركیبی پیشنهادی tsp فروشنده دوره گرد موجود در سایت در اغلب مسائل قادر است جواب بهتری بدست آورد.

وازه های كلیدی
فروشنده دوره گرد، الگوریتم تركیبی، الگوریتم كلونی مورچگان، الگوریتم ژنتیك

یک روش ترکیبی براي حل مساله فروشنده دوره گرد

[DOWN]http://dl.azardl.com/sh/moorche.pdf[/DOWN]

يک شبکه عصبی فازی ژنتيکی جديد برای حل مسأله فروشنده دور ه گرد

[DOWN]http://dl.azardl.com/sh/icee_533.pdf[/DOWN]

حل مساله فروشنده دوره‌گرد احتمالي توسط اتوماتاي يادگير توزيع شده


[DOWN]http://dl.azardl.com/sh/124.pdf[/DOWN]

حل مساله فروشنده دوره گرد پويا توسط اتوماتاهاي يادگير واكنشي توزيع شده

[DOWN]http://dl.azardl.com/sh/ICIKT02_122_236168.pdf[/DOWN]

مساله فروشنده دوره گرد تعميم‌يافته



[DOWN]http://dl.azardl.com/sh/ICIORS02_349_236580.pdf[/DOWN]

مقاله اي در زمينه حل tsp به روش الگوریتم ژنتیک

[DOWN]http://dl.azardl.com/sh/7236.pdf[/DOWN]

يك روش تركيبي مبتني بر خوشه بندي براي حل مساله فروشنده دوره گرد با مقياس بزرگ



خلاصه مقاله:

يكي از مسائل بسيار مهم در تئوري گراف ها، مساله فروشنده دوره گرد مي باشد كه يك مساله NP-Complete است. اكثر مسائلي كه مي توان انها را با مساله فروشنده دوره گرد مدل كرد، داراي مقياس خيلي بزرگ هستند كه الگوريتم هاي موجود قادر به حل انها در يك زمان قابل قبول نيستند. آتوماتاهاي يادگير و الگوريتم هاي ژنتيكي هر دو از ابزارهاي جستجو مي باشند كه براي حل بسياري از مسائل NP-Complete بكار برده ميشوند. در اين مقاله يك الگوريتم تركيبي (الگوريتم ژنتيك + آتوماتاي يادگير) مبتني بر خوشه چيني براي حل مساله فروشنده دوره گرد با مقياس بزرگ پيشنهاد شده است. اين الگوريتم ابتدا با استفاده از تكنيك خوشه بندي، مساله اصلي را به چند زير مساله با مقياس كوچك افراز كرده و سپس از دو روش الگوريتم هاي ژنتيكي و اتوماتاي يادگيري بطور همزمان براي جستجو در فضاي حالت و حل هر زير مساله استفاده مي نمايد، نشان داده شده است كه با استفاده همزمان از آتوماتاي يادگير و الگوريتم ژنتيك در فرايند جستجو، سرعت رسيدن به جواب افزايش چشمگيري پيدا ميكند و همچنين از بدام افتادن الگوريتم در حداقل هاي محلي جلوگيري مي نمايد. نتايج آزمايش ها، برتري الگوريتم تركيبي را نسبت به الگوريتم ژنتيكي و آتوماتاهاي يادگير نشان ميدهد و همچنين با استفاده از تكنيك خوشه بندي و اجراي الگوريتم تركيبي بطور همزمان بر روي هر خوشه – با يك سيستم چند پردازنده اي – مي توان زمان لازم براي حل مساله را به حداقل مقدار ممكن كاهش داد.

كلمات كليدي:

مساله فروشنده دوره گرد ، آتوماتاي يادگير ، الگوريتم ژنتيك ، خوشه بندي


[DOWN]http://dl.azardl.com/sh/461.pdf[/DOWN]

بکارگيري الگوريتم رقابت استعماري در حل مسئله فروشنده دوره گرد



[DOWN]http://dl.azardl.com/sh/IIEC06_182_236659.pdf[/DOWN]

الگوریتم بهینه سازی کلونی مورچه ها، و یا به اختصار الگوریتم مورچه ها، از رفتار مورچه های طبیعی که در مجموعه ها بزرگ در کنار هم زندگی می کنند الهام گرفته شده است و یکی از الگوریتم های بسیار کارآمد در حل مسائل بهینه سازی ترکیبی است. الگوریتم های دیگری نیز بر اساس الگوریتم مورچه ها ساخته شده اند که همگی سیستم های چند عاملی هستند و عامل ها مورچه های مصنوعی یا به اختصار مورچه هایی هستند که مشابه با مورچه های واقعی رفتار می کنند. الگوریتم مورچه ها، یک مثال بارز از هوش جمعی هستند که در آن عامل هایی که قابلیت چندان بالایی ندارند، در کنار هم و با همکاری یکدیگر می توانند نتایج بسیار خوبی به دست بیاورند. این الگوریتم برای حل و بررسی محدوده وسیعی از مسائل بهینه سازی به کار برده شده است. از این میان می توان به حل مسأله کلاسیک فروشنده دوره گرد و همچنین مسأله راهیابی در شبکه های مخابرات راه دور اشاره نمود.

مساله فروشنده دوره گرد (Traveling Salesman Problem) و یا به اختصار TSP، يكي از مسائل مشهور بهينه سازي تركيبي است. در این مسأله، يك فروشنده دوره گرد مي خواهد به چند شهر سفر کند و كالاي خود را به فروش برساند. اما می بایست از تمام شهرها عبور کند، از هر شهر فقط يك بار عبور كند و با طی کوتاه ترین مسير، سفر خود را به پایان برساند. حل این مساله کاربردهای وسیعی در حوزه های مختلف مهندسی دارد. از جمله مسائلی که از نظر ریاضی با مسأله TSP معادل هستند، می توان به حل انواع مسایل زمانبندی، مسیریابی، جایابی کالا در انبار، جایابی ماشینها در کارگاه ها، و طراحی مدارات چاپی اشاره نمود.

دانلود رایگان کد الگوریتم بهینه سازی کلونی مورچه ها برای حل مسأله فروشنده دوره گرد

کد جاوای الگوریتم فروشنده ی دوره گرد

کد:

---

import java.applet.*;
import java.util.*;
import java.awt.*;
import java.net.*;
import java.io.*;

public class TSP extends Applet implements Runnable {

    public int    NCITY = 5;
    public int    NGEONEURON;
    public static final double    COUNTRY = 1.00;
    public static final double    NEAR = 0.05;
   
  public static final Color bkC = new Color(0x000090);   
  public static final Color bk2C = new Color(0x000050);   
  public static final Color lnC = new Color(0xff0000);   
  public static final Color ln2C = new Color(0xcccc00);   
  public static final Color fgC = new Color(0xffffff);   

    public Image  homeI,offscreen;
  public int imagewidth ,imageheight;
    public Thread  animator    = null;
    public boolean please_stop = false;
    Font mF = new Font("Courier", Font.BOLD, 12);
    Font sF = new Font("Courier", Font.BOLD, 8);
  public int counter;
   
    public City city[];
    public geoNeuron gn[];
   
    public double r[][];
   
    public double theta, phi, momentum;
   
    public Scrollbar cscroll;

    ///////////////////////////////////////////////////////////////////
    //
    //  Init section
    //
    ///////////////////////////////////////////////////////////////////

        public void kohonenInit(){
            theta = 0.5;
        phi  = 0.5;
        momentum = 0.995;

            NCITY = cscroll.getValue()/10;
            NGEONEURON = NCITY*2;
           
          //URL url;       
      //homeI = this.getImage(this.getDocumentBase(), "home.gif");
       
      city = new City[NCITY];
      for(int i = 0; i<NCITY; i++) city[i] = new City(Math.random()*COUNTRY, Math.random()*COUNTRY);
     
      double alpha = 0.0;     
      gn = new geoNeuron[NGEONEURON];
      for(int i = 0; i<NGEONEURON; i++){
        gn[i] = new geoNeuron(0.5+0.5*Math.cos(alpha),0.5+0.5*Math.sin(alpha));
        alpha += Math.PI *2.0 / (double)(NGEONEURON);
      }
     
      r = new double[NGEONEURON][NGEONEURON];
     
      makeR(theta);       

            counter = 0;
       
        }

    ///////////////////////////////////////////////////////////////////
    //
    //  Problem section
    //
    ///////////////////////////////////////////////////////////////////

        public void makeR(double th){
        //System.out.println("");
      for(int i=0; i<NGEONEURON; i++){
          r[i][i]= 1.0;
          for(int j=i+1; j<NGEONEURON; j++){
              r[i][j] = Math.exp( -1.0 * ( gn[i].dist(gn[j])*gn[i].dist(gn[j]) )/(2.0*th*th));
              r[j][i] = r[i][j];
                //System.out.print(" "+r[i][j]);
          }
          //System.out.println("");
      }
        }

    // The body of the animator thread.
    public void run() {
        int idx,j;
        double x1,x2,mindist;
        int count = 0;
        while(!please_stop) {
           
            counter++;
           
            // CHOSE A RANDOM PATTERN
            idx = (int)(Math.random()*NCITY);
            x1 = city[idx].x+(Math.random()*NEAR)-NEAR/2;
            x2 = city[idx].y+(Math.random()*NEAR)-NEAR/2;
            city[idx].choose++;
         
            // SEARCH FOR MINIMAL
            mindist = 100000.0;
            j = -1;
            for(int i=0; i<NGEONEURON;i++){
                double d = (x1 - gn[i].wx)*(x1 - gn[i].wx) + (x2 - gn[i].wy)*(x2 - gn[i].wy);
                //double d = x1*gn[i].wx + x2*gn[i].wy;
                //System.out.println("d="+d);
                if(d < mindist){
                    mindist = d;
                    j = i;
                }
            }
                       
            gn[j].update++;
                   
            // UPDATE WEIGHTS
            for(int i=0; i<NGEONEURON;i++){
                gn[i].wx += (phi * r[i][j] * (x1 - gn[i].wx));
                gn[i].wy += (phi * r[i][j] * (x2 - gn[i].wy));
            }
                                         
            // DECREASE LEARNING PARAMETERS
            phi *= momentum;
            theta *= momentum;
           
            // RE-COMPUTE r MATRIX
                makeR(theta);
               
               
                // PLOT RESULT EVERY 10 SESSIONS
                count = (count++)%10;
               
                  if(count==0){
                      //System.out.println("theta = "+theta+"  phi = "+phi);

                            paint(this.getGraphics());
           
                            // Call Garbage Collect
                            //System.gc();
           
                try {Thread.sleep(10);} catch (InterruptedException e){};
            }
        }
        animator = null;
    }
   
    ///////////////////////////////////////////////////////////////////
    //
    //  Functional section
    //
    ///////////////////////////////////////////////////////////////////
   
    public void init() {
   
        cscroll = new Scrollbar(Scrollbar.HORIZONTAL,NCITY*10, 10, 30, 200);
        cscroll.setLineIncrement(10);
        cscroll.setPageIncrement(10);
        add(cscroll);
       
        kohonenInit();   
    }

    private int toXReal(double val){int w = this.size().width;return (int)(val *((double)w/2.0-50.0) / COUNTRY +25.0);}
    private int toYReal(double val){int h = this.size().height;return (int)(val *((double)h-50.0) / COUNTRY +25.0);}
 
    private int to2XReal(double val){int w = this.size().width;return (int)((double)w/2.0 + val *((double)w/2.0-50.0) / COUNTRY +25.0);}
    private int to2YReal(double val){int h = this.size().height;return (int)(val *((double)h-50.0) / COUNTRY +25.0);}
   
    public void paintLeft(Graphics g) {
                Dimension size = this.size();
                        int w = size.width, h = size.height;
                       
                        g.setFont(mF);
                       
                        // CLEAR ALL
            g.setColor(bkC);
            g.fillRect(0, 0, w, h);
            // DRAW GRID
            g.setColor(bk2C);
            for(double i=0; i<=COUNTRY; i+=(COUNTRY/20.0)){
                g.drawLine(toXReal(0.0),toYReal(i),toXReal(COUNTRY),toYReal(i));
                g.drawLine(toXReal(i),toYReal(0.0),toXReal(i),toYReal(COUNTRY));
            }
           
            //DRAW PATH
            g.setColor(lnC);
            for(int i=0; i<NGEONEURON; i++){
                g.drawLine( toXReal(gn[i].wx),toYReal(gn[i].wy),
                  toXReal(gn[(i+1)%NGEONEURON].wx),toYReal(gn[(i+1)%NGEONEURON].wy) );
                g.drawString(""+i+"-"+(gn[i].update*100/counter)+"%",toXReal(gn[i].wx),toYReal(gn[i].wy));
            }

            g.setColor(fgC);
           
            // DRAW CITYS
            for(int i=0; i<NCITY; i++){
                g.drawOval( toXReal(city[i].x)-4, toYReal(city[i].y)-4,8,8);
                g.drawString(""+i+"-"+(city[i].choose*100/counter)+"%",toXReal(city[i].x),toYReal(city[i].y)+8);
            }
      }   
        public void paintRight(Graphics g) {
                Dimension size = this.size();
                        int w = size.width, h = size.height;
   
                        // CLEAR ALL
            g.setColor(bkC);
            g.fillRect(0, 0, w, h);

                        g.setFont(sF);

            // DRAW CITYS
            g.setColor(fgC);
            for(int i=0; i<NCITY; i++){
                g.drawOval( to2XReal(city[i].x)-4, to2YReal(city[i].y)-4,8,8);
                //g.drawString("["+city[i].wx+";"+gn[i].wy+"]",to2XReal(gn[i].x),to2YReal(gn[i].y));
            }
         
            g.setColor(ln2C);
            for(int i=0; i<NGEONEURON; i++)
                      for(int j=i+1; j<NGEONEURON; j++){
                          g.drawLine( to2XReal(gn[i].x),to2YReal(gn[i].y),
                              to2XReal(gn[j].x),to2YReal(gn[j].y));
                        g.drawString(""+r[i][j],to2XReal((gn[i].x+gn[j].x)/2),to2YReal((gn[i].y+gn[j].y)/2));
                          //r[i][j] = Math.exp( -1.0 * (double)( gn[i].dist(gn[j])*gn[i].dist(gn[j]) )/(2.0*th));
                         
                      }
                        g.setFont(mF);
            g.setColor(fgC);
                  g.drawString("phi="+phi+" theta="+theta,to2XReal(0.0),to2YReal(0.0)+20);
    }   

    public void paint(Graphics g) {
                Dimension size = this.size();
                        int w = size.width, h = size.height;
                       
                        this.setBackground(bkC);

                       
                        if ((offscreen == null) || ((imagewidth != w) || (imageheight != h))) {
                offscreen = this.createImage(w, h);
                imagewidth = w;
                imageheight = h;
            }
                       
                        Rectangle clip = new Rectangle(toXReal(0),toYReal(0),toXReal(COUNTRY),toYReal(COUNTRY));
                                               
                        Graphics goff = offscreen.getGraphics();
                        goff.clipRect(clip.x, clip.y, clip.width, clip.height);
            Graphics g1 = this.getGraphics();
                        g1.clipRect(clip.x, clip.y, clip.width, clip.height);
                       
            paintLeft(goff);
            g1.drawImage(offscreen, 0, 0, this);
           
                        //clip = new Rectangle(to2XReal(0),to2YReal(0),to2XReal(COUNTRY),to2YReal(COUNTRY));
                                   
                      //goff = offscreen.getGraphics();
                        //goff.clipRect(clip.x, clip.y, clip.width, clip.height);
            //g1 = this.getGraphics();
                        //g1.clipRect(clip.x, clip.y, clip.width, clip.height);
                       
            //paintRight(goff);
            //g1.drawImage(offscreen, 0, 0, this);
           
            clip = null;
            goff = null;
            g1 = null;
            System.gc();
           
            // CLEAR ALL
            g.setColor(bkC);
            g.fillRect(w/2+30,0,w/2+130, 20);
            g.setColor(fgC);

            g.drawString("# of city:"+cscroll.getValue()/10,w/2+30,20);

    }
 
    // Start the animation
    public void start() {
        animator = new Thread(this);
       
        animator.start();
       
    }
    // Stop it.
    public void stop() {
        if (animator != null) animator.stop();
        animator = null;
    }
   
    // Stop and start animating on mouse clicks.
    public boolean mouseDown(Event e, int x, int y) {
    // if running, stop it.  Otherwise, start it.
      if (animator != null){
          please_stop = true;
      }else{
          please_stop = false;
                animator = new Thread(this);
               
                kohonenInit();
        animator.start();
      }
      return true;
    }

}

---

حل TSP با Genetic Algorithms در #C
و روش حل با Simulated Annealing

حل مسئله فروشنده دوره گرد (TSP) استفاده از شبکه عصبی خود سازمانده (SOM)
A Novel Approach for Solving STP using SOM


[DOWN]http://dl.azardl.com/sh/final_paper_1_.pdf[/DOWN]

دانلود رایگان کد الگوریتم شبیه سازی تبرید برای مسأله فروشنده دوره گرد

الگوریتم شبیه سازی تبرید یا Simulated Annealing و یا به اختصار SA، یکی از قوی ترین الگوریتم های در زمینه بهینه سازی ترکیباتی یا Combinatorial Optimization است.
این الگوریتم در سال ۱۹۸۳ توسط کیرکپاتریک و همکارانش ارائه گردید و در همان مقاله اصلی، بر روی مسأله فروشنده دوره گرد یا TSP اعمال شد.
متلب سایت در این پست، کد آماده متلب را که در آن مسأله TSP بااستفاده از الگوریتم SA حل شده است

سلام و از زحمات شما متشکرم، لطفا بررسی فرمایید لینک مقال زیر درست عمل نمی کند:
حل مسئله فروشنده دوره گرد (tsp) استفاده از شبکه عصبی خود سازمانده (som)

نقل قول:

---

نوشته اصلی توسط ayasemi

سلام و از زحمات شما متشکرم، لطفا بررسی فرمایید لینک مقال زیر درست عمل نمی کند:
حل مسئله فروشنده دوره گرد (tsp) استفاده از شبکه عصبی خود سازمانده (som)

---

اینها را چهار سال قبل گذاشتم و الان دیگه ندارم که دوباره اپلود کنم :afd:
میگردم پیداکردم حتما دوباره قرار میدم biboss:.