LeetCode/C++/1226.cpp at master · strengthen/LeetCode · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
__________________________________________________________________________________________________
sample 64 ms submission
class DiningPhilosophers {
    int n;
    vector<std::mutex> fork_locks;
public:
    DiningPhilosophers() {
        n = 5;
        fork_locks = vector<std::mutex>(n);
    }

    void wantsToEat(int philosopher,
                    function<void()> pickLeftFork,
                    function<void()> pickRightFork,
                    function<void()> eat,
                    function<void()> putLeftFork,
                    function<void()> putRightFork) {
		int left_id = philosopher % n;
        int right_id = (philosopher+1) % n;

        if (philosopher % n == 1) {
            fork_locks[right_id].lock();
            fork_locks[left_id].lock();
            pickRightFork();
            pickLeftFork();
            eat();
            putLeftFork();
            putRightFork();
            fork_locks[left_id].unlock();
            fork_locks[right_id].unlock();
        } else {
            fork_locks[left_id].lock();
            fork_locks[right_id].lock();
            pickRightFork();
            pickLeftFork();
            eat();
            putLeftFork();
            putRightFork();
            fork_locks[right_id].unlock();
            fork_locks[left_id].unlock();
        }
    }
};

class DiningPhilosophers2 {
    mutex *ms;

public:
    DiningPhilosophers2() {
        ms = new mutex[5];
    }

    void wantsToEat(int philosopher,
                    function<void()> pickLeftFork,
                    function<void()> pickRightFork,
                    function<void()> eat,
                    function<void()> putLeftFork,
                    function<void()> putRightFork) {
		int first_lock = -1, second_lock = -1;
        if (philosopher == 4) {
            first_lock = 4;
            second_lock = 0;
        }
        else if (philosopher % 2 == 0) {
            first_lock = philosopher;
            second_lock = philosopher+1;
        } else {
            first_lock = philosopher+1;
            second_lock = philosopher;
        }

        //cout << first_lock << " " << second_lock << endl;

      //  scoped_lock lock(ms[first_lock], ms[second_lock]);
        ms[first_lock].lock();
        ms[second_lock].lock();
        pickLeftFork();
        pickRightFork();
        eat();
        putLeftFork();
        putRightFork();

        ms[second_lock].unlock();
        ms[first_lock].unlock();
    }
};
__________________________________________________________________________________________________
sample 68 ms submission
class DiningPhilosophers {
public:
    DiningPhilosophers() {
    }
    ~DiningPhilosophers() = delete;


    void wantsToEat(int philosopher,
                    function<void()> pickLeftFork,
                    function<void()> pickRightFork,
                    function<void()> eat,
                    function<void()> putLeftFork,
                    function<void()> putRightFork) {
        if (philosopher == 0) {
            this->do_after_other(N - 1, pickRightFork, putRightFork, 0, pickLeftFork, putLeftFork, eat);
        } else {
            this->do_after_other(philosopher, pickLeftFork, putLeftFork, philosopher - 1, pickRightFork, putRightFork, eat);
        }
    }

private:
    static constexpr int N = 5;
    array<mutex, N> forks;

    void do_after_other(
        int idx1, function<void()> prepare1, function<void()> cleanup1,
        int idx2, function<void()> prepare2, function<void()> cleanup2,
        function<void()> action) {

        lock_guard<mutex> lk_1(this->forks[idx1]);
        lock_guard<mutex> lk_2(this->forks[idx2]);
        prepare1();
        prepare2();
        action();
        cleanup1();
        cleanup2();
    }
};
__________________________________________________________________________________________________