Das Ziegenproblem

#include <iostream>
#include <cstdlib>
#include <QThread>
 
class Simulation : public QThread {
 
  private:
    // Konstanten fuer den Zufallszahlengenerator
    static const unsigned long MASK = (1L << 48) - 1;
    static const unsigned long ADD = 0xBL;
    static const unsigned long MULTIPLIER = 0x5DEECE66DL;
    // Hier werden die letzten Zufallszahln gespeichert
    unsigned long m_random[3];
    // Durchlaufzaehler
    int m_counter;
    // mit oder ohne Wechseln
    bool m_shift;
    // Zeiger auf den Gewinnzaehler
    int *m_wins;
 
  public:
    Simulation(int counter, bool shift, int *wins) {
      m_counter = counter;
      m_shift = shift;
      m_wins = wins;
      // Drei unabhaengige Zufallszahlengeneratoren initialisieren
      for (int i=0;i<3;i++) {
        m_random[i] = rand();
      }
    }
 
  protected:
    void run() {
      // So oft hat der Kandidat in diesem Thread schon gewonnen
      int wins = 0;
      while (m_counter > 0) {
        // Das Auto wird versteckt
        int car = getRandom(3,0);
        // Der Kandidat entscheidet sich fuer eine Tuer
        int kandidat = getRandom(3,1);
        // Diese Tueren darf der Moderator nicht oeffnen
        bool blocked[3];
        for (int i=0;i<3;i++) {
          blocked[i] = false;
        }
        // Naemlich die mit dem Auto
        blocked[car] = true;
        // und die mit dem Kandidaten
        blocked[kandidat] = true;
        // Jetzt sucht er sich zufaellig Tueren raus, bis
        // eine nicht blockiert ist, und oeffnet diese
        int opened;
        do {
          opened = getRandom(3,2);
        } while (blocked[opened]);
        // Je nachdem, was simuliert wird: Wechseln oder nicht.
        if (m_shift) {
          // Das ist genau die andere verschlossene Tuer
          kandidat = 3 - (kandidat + opened);
        }
        // Gewinnt der Kandidat das Auto?
        if (car == kandidat) {
          wins++;
        }
        // Durchlauf vorbei: Zaehler eins runterzaehlen
        m_counter--;
      }
      // Zum Gesamtergebnis dazuaddieren
      (*m_wins) += wins;
    }
 
  private:
    int getRandom(long n, int i) {
      // linearer Kongruenzgenerator
      m_random[i] = (MULTIPLIER*m_random[i]+ADD)%MASK;
      return static_cast<int>(m_random[i]%n);
    }
 
};

#include <vector>
#include <iostream>
 
#include "Simulation.hpp"
 
class LetsMakeADeal {
 
  private:
    // So viele Threads sollen gleichzeitig laufen
    int m_threads;
 
  public:
    LetsMakeADeal(int threads) {
      m_threads = threads;
      // Titel ausgeben
      std::cout << std::endl;
      std::cout << "Simulation der TV-Show Let's make a deal: "
                << "Das Ziegenproblem" << std::endl;
      std::cout << std::endl;
    }
 
    void tvShow(int runs, bool shift) {
      // Gewinne zaehlen
      int wins = 0;
      // Hier werden die verschiedenen Threads gespeichert
      std::vector<Simulation*> theThreads;
      // Der erste Thread faengt den Fehler der Integerdivision ab
      int counter = runs / m_threads + runs % m_threads;
      theThreads.push_back(new Simulation(counter,shift,&wins));
      // Der Rest wird auf die anderen Threads aufgeteilt
      counter = runs / m_threads;
      for (int i=1;i<m_threads;i++) {
        theThreads.push_back(new Simulation(counter,shift,&wins));
      }
      // Threads starten
      for (int i=0;i<m_threads;i++) {
        theThreads.at(i)->start();
      }
      // Bis alle Threads fertig sind warten
      for (int i=0;i<m_threads;i++) {
        theThreads.at(i)->wait();
      }
      // Das Ergebnis der Simulation ausgeben
      std::cout << "Simulation " << (shift ? "mit" : "ohne")
                << " Wechsel der Tuer." << std::endl;
      std::cout << wins << " Gewinne in " << runs
                << " Runden." << std::endl;
      std::cout << "Anteil der Gewinne: "
                << ((double)wins)/((double)runs) << std::endl;
      std::cout << std::endl;
    }
 
};

#include "LetsMakeADeal.hpp"
 
int main() {
  // So oft soll simuliert werden
  const int RUNS = 2147483647;
  // So viele Threads sollen benutzt werden
  const int THREADS = 2;
  // Zufallszahlengenerator initialisieren
  srand((unsigned)time(NULL));
  // Simuliere mit Threads
  LetsMakeADeal* theShow = new LetsMakeADeal(THREADS);
  // Zuerst mit Wechseln
  theShow->tvShow(RUNS,true);
  // dann ohne Wechseln
  theShow->tvShow(RUNS,false);
  return 0;
}