Hỏi về code phương trình bậc 2 bằng C

Mã:
(3, 0)
(1, 150)
(1, 200)
(1, 180)
(3, 360)
(4, 30)
(1, 300)
(4, 150)
(6, 200)
(3, 120)
(1, 0)
(3, 80)
(3, 200)
(1, 120)
(4, 150)
(1, 240)
(3, 320)
(1, 60)
(2, 360)
(4, 200)
Tam giac deu: (3, 80), (3, 200), (3, 320)
Tam giac vuong: (1, 180), (1, 0), (1, 150)
Tam giac vuong: (1, 180), (1, 0), (1, 200)
Tam giac vuong: (1, 180), (1, 0), (1, 300)
Tam giac vuong: (1, 180), (1, 0), (1, 120)
Tam giac vuong: (1, 180), (1, 0), (1, 240)
Tam giac vuong: (1, 180), (1, 0), (1, 60)
Tam giac vuong: (1, 300), (1, 120), (1, 150)
Tam giac vuong: (1, 300), (1, 120), (1, 200)
Tam giac vuong: (1, 300), (1, 120), (1, 180)
Tam giac vuong: (1, 300), (1, 120), (1, 0)
Tam giac vuong: (1, 300), (1, 120), (1, 240)
Tam giac vuong: (1, 300), (1, 120), (1, 60)
Tam giac deu: (1, 0), (1, 120), (1, 240)
Tam giac vuong: (1, 240), (1, 60), (1, 150)
Tam giac vuong: (1, 240), (1, 60), (1, 200)
Tam giac vuong: (1, 240), (1, 60), (1, 180)
Tam giac vuong: (1, 240), (1, 60), (1, 300)
Tam giac vuong: (1, 240), (1, 60), (1, 0)
Tam giac vuong: (1, 240), (1, 60), (1, 120)

Mã:
#include <conio.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#define MAX 1000 // so phan tu dau vao


int main() {
    int i, j, k, h, n, m; // bien vong lap
    int pos; // vi tri xet
    int flag; // co xet


    FILE *f; // con tro file


    // luu data dau vao
    struct polar
    {
        int r; // luu r dau vao
        int pi; // luu pi dau vao
        int flag; //
    } polar[MAX];


    // luu ket qua loc
    struct save{
        int r; // luu r
        int pi[MAX]; // luu pi khac
        int n; // so phan tu pi
    } save;


    /*
    doc data
    */
    f = fopen("input.text","rt"); // mo file


    fscanf(f, "%d", &n); // do so phan tu dong dau


    for (i = 0; i < n; i++) // doc va in du lieu ra man hinh
    {
        fscanf(f, "%d %d", &polar[i].r, &polar[i].pi); // doc du lieu vao struct
        polar[i].flag = 1; // dat co xet
        printf("(%d, %d)\n", polar[i].r, polar[i].pi); // in ra man hinh
    }
    fclose(f); // dong file


    /*
    loc cap r trung PI khac
    */
    pos = 0; // phan tu lam moc xet


    do
    {
        if (polar[pos].flag == 0) // da xet, bo qua vong nay
        {
            pos += 1;
            continue;
        }


        // co ghi nhay cach pos
        flag = 0;


        // luu phan tu lam moc
        save.r = polar[pos].r;
        save.pi[0] = polar[pos].pi;
        save.n = 0;


        // tim trung r
        for (j = pos + 1; j < n; j++)
        {
            if (polar[j].flag == 0) // bo qua neu da xet
            {
                continue;
            }
            else // chua xet
            {
                if (polar[j].r == save.r) // r trung
                {
                    polar[j].flag = 0; // bat co da xet


                    if (polar[j].pi != save.pi[0]) // pi khac
                    {
                        save.pi[save.n + 1] = polar[j].pi; // luu pi vao save
                        save.n += 1; // tang so phan tu save
                    }
                }
                else // r khac
                {
                    if (flag == 0) // ghi vi tri, bat co nhay pos lan dau
                    {
                        pos = j;
                        flag = 1;
                    }
                }
            }
        }


        // cung r trung ma co 3 pi khac, loc dinh tam giac vuong hoac deu
        if (save.n + 1 > 2)
        {
            for(i = 0; i < save.n + 1; i++)
            {
                for (k = i + 1; k < save.n + 1; k++)
                {
                    // tam giac vuong
                    if (abs(save.pi[i] - save.pi[k]) == 180)
                    {
                        for (m = 0; m < save.n + 1; m++)
                        {
                            if ((m != i) && (m != k))
                            {
                                printf("Tam giac vuong: (%d, %d), (%d, %d), (%d, %d)\n", save.r, save.pi[i], save.r, save.pi[k], save.r, save.pi[m]);
                            }
                        }
                    }


                    // tam giac deu
                    if (abs(save.pi[i] - save.pi[k]) == 120)
                    {
                        for (h = k + 1; h < save.n + 1; h++)
                        {
                            if (abs(save.pi[h] - save.pi[k]) == 120)
                            {
                                printf("Tam giac deu: (%d, %d), (%d, %d), (%d, %d)\n", save.r, save.pi[i], save.r, save.pi[k], save.r, save.pi[h]);
                            }
                        }
                    }
                }
            }
        }


        // khong nhay cach tang pos len 1
        if (flag == 0) pos += 1;
    } while (pos < n - 1);


    getch();
}

Còn bạn nào có thuật toán cao hơn thì cứ post nha (mình tự học lập trình chứ không qua trường lớp đâu, nói mấy công thức toán cao cấp cũng chịu, thuật toán tự nghĩ ra là chính, con người xử lý thế nào, cho máy xử lý thế đó, công đoạn nào lược bớt được thì rút ngắt thời gian xử lý, với mình đó gọi là tối ưu)
 
Đây là code của em (trừ phần đầu struct là của thầy viết). Thầy khen viết như vầy mới chạy nhanh và tối ưu được.
[ah]
Mã:
template<class T>
struct Vector {
    T *a = 0;
    int n = 0, cap = 1;

    Vector():Vector(1) { }

    Vector(int N) {
        a = new T[N];
        cap = N;
    }

    ~Vector() {
        delete[] a;
        cap = n = 0;
    }

    void operator = (const Vector &another) {
        if (this == &another)
            return;
        cap = another.cap;
        n = another.n;
        delete[] a;
        a = new int[n];
        for (int i = 0; i < n; ++i)
            a[i] = another.a[i];
    }

    Vector(const Vector &another) {
        *this = another;
    }

    void push_back(int x) {
        if (n == cap) {
            cap *= 2;
            a = (T*)realloc(a, sizeof(int) * cap);
        }
        a[n++] = x;
    }
};

int triangles1() {
    Vector<int> *v = new Vector<int>[100001];
    int flag[400], N, r, theta;

    FILE *f = fopen(FI, "r");
    fscanf(f, "%d\n", &N);

    for (int i = 0; i < N; i++) {
        fscanf(f, "%d %d\n", &r, &theta);
        v[r].push_back(theta);
    }
    fclose(f);

    int mark = 0, ans = 0;

    for (int i = 1; i <= 100000; i++) {
        mark++;
        int m = v[i].n;
        for (int j = 0; j < m; j++) {
            int x = (v[i].a[j] + 180) % 360;
            if (flag[x] == mark)
                ans += m - 2;
            int a = (v[i].a[j] + 120) % 360;
            int b = (a + 120) % 360;
            if (flag[a] == mark && flag[b] == mark)
                ans++;
            flag[v[i].a[j]] = mark;
        }
    }
    delete[] v;
    return ans;
}
[/ah]

Code của bạn thì chắc em phải sửa lại để cho dễ xem:
[ah]
Mã:
#define MAX 1000 // so phan tu dau vao

int triangles2() {
    int i, j, k, h, n, m; // bien vong lap
    int pos; // vi tri xet
    int flag; // co xet

    int ans = 0;

    FILE *f; // con tro file

             // luu data dau vao
    struct polar
    {
        int r; // luu r dau vao
        int pi; // luu pi dau vao
        int flag; //
    } polar[MAX];

    // luu ket qua loc
    struct save {
        int r; // luu r
        int pi[MAX]; // luu pi khac
        int n; // so phan tu pi
    } save;

    /*
    doc data
    */
    f = fopen(FI, "rt"); // mo file

    fscanf(f, "%d", &n); // do so phan tu dong dau

    for (i = 0; i < n; i++) // doc va in du lieu ra man hinh
    {
        fscanf(f, "%d %d", &polar[i].r, &polar[i].pi); // doc du lieu vao struct
        polar[i].flag = 1; // dat co xet
        //printf("(%d, %d)\n", polar[i].r, polar[i].pi); // in ra man hinh
    }
    fclose(f); // dong file

               /*
               loc cap r trung PI khac
               */
    pos = 0; // phan tu lam moc xet

    do
    {
        if (polar[pos].flag == 0) // da xet, bo qua vong nay
        {
            pos += 1;
            continue;
        }

        // co ghi nhay cach pos
        flag = 0;

        // luu phan tu lam moc
        save.r = polar[pos].r;
        save.pi[0] = polar[pos].pi;
        save.n = 0;

        // tim trung r
        for (j = pos + 1; j < n; j++)
        {
            if (polar[j].flag == 0) // bo qua neu da xet
            {
                continue;
            }
            else // chua xet
            {
                if (polar[j].r == save.r) // r trung
                {
                    polar[j].flag = 0; // bat co da xet

                    if (polar[j].pi != save.pi[0]) // pi khac
                    {
                        save.pi[save.n + 1] = polar[j].pi; // luu pi vao save
                        save.n += 1; // tang so phan tu save
                    }
                }
                else // r khac
                {
                    if (flag == 0) // ghi vi tri, bat co nhay pos lan dau
                    {
                        pos = j;
                        flag = 1;
                    }
                }
            }
        }

        // cung r trung ma co 3 pi khac, loc dinh tam giac vuong hoac deu
        if (save.n + 1 > 2)
        {
            for (i = 0; i < save.n + 1; i++)
            {
                for (k = i + 1; k < save.n + 1; k++)
                {
                    // tam giac vuong
                    if (abs(save.pi[i] - save.pi[k]) == 180)
                    {
                        for (m = 0; m < save.n + 1; m++)
                        {
                            if ((m != i) && (m != k))
                            {
                                ++ans;
                                //printf("Tam giac vuong: (%d, %d), (%d, %d), (%d, %d)\n", save.r, save.pi[i], save.r, save.pi[k], save.r, save.pi[m]);
                            }
                        }
                    }

                    // tam giac deu
                    if (abs(save.pi[i] - save.pi[k]) == 120)
                    {
                        for (h = k + 1; h < save.n + 1; h++)
                        {
                            if (abs(save.pi[h] - save.pi[k]) == 120)
                            {
                                ++ans;
                                //printf("Tam giac deu: (%d, %d), (%d, %d), (%d, %d)\n", save.r, save.pi[i], save.r, save.pi[k], save.r, save.pi[h]);
                            }
                        }
                    }
                }
            }
        }

        // khong nhay cach tang pos len 1
        if (flag == 0) pos += 1;
    } while (pos < n - 1);
    return ans;
}
[/ah]
 
Bạn có thể đưa cho thầy của bạn xem thuật toán nào tối ưu hiệu suất công việc hơn, chứ mình không động đến pascal từ lâu rồi, cũng không bằng không cấp dù có nói đúng cũng không ai tin (pascal mình học từ cấp 2 môn tin học)

Chưa hiểu rõ cơ sở thuật toán của thầy bạn làm nên không cơ sở nói chính xác:

Chỉ nói điều mình dễ nhìn thấy trong code bạn luôn thực hiện 100000 vòng lặp chính (chưa kể vòng lặp con bên trong)

Còn của mình sẽ rút ngắn công việc dựa vào dư liệu nhập (nó không phải code quy chuẩn thành thuật toán tổng quát: tìm kiếm, liệt kệ, ...), chứ không phải liệt kệ 100000 giá trị r

n điểm có giá trị r hoàn toàn khác nhau thì xét n + (n - 1) + (n - 2) ... + 1 vòng lặp

nếu có điểm r trùng giá trị với giá trị r xét làm mốc => thì các vòng lặp (n - x) nó của các giá r đã xét trùng sẽ được bỏ quả => càng nhiều r trùng giá trị thì số lượng vòng lặp được rút gọn càng lớn => công việc rút ngắn càng nhanh
 

tengiday

Happy life
@LanSG9x: Bài thầy cho bạn là 1 cái gift. Vì dữ liệu quá nhỏ n < 1000 nên tối ưu ko cần nhiều mà vẫn chạy nhanh. Cách làm của 'triangles1' chỉ thể hiện ưu thế khi n lớn thôi. Mình đoán n tới 20000 thì 'triangles1' sẽ bắt đầu nhanh hơn 'triangles2'.

'triangles1' chỉ có độ phức tạp O(n) thôi. Thật ra nó là O(10^5 + n). Lưu ý đây là phép cộng. Bạn xem xét đoạn code lại sẽ thấy 2 vòng loop chỉ chạy 10^5 + n lần. Bạn đừng bị đánh lừa. :) Bởi vì lúc nào cũng phải chạy 10^5 nên bạn có thể xem như là overhead fee nên khi dữ liệu nhỏ nó luôn luôn chạy chậm.
[ah]
Ý tưởng của 'triangles1' là dựa trên Hough transform (tìm số đường thẳng đi qua ít nhất k điểm trong số n điểm cho trước), và nó chỉ hiệu quả với tọa độ nguyên. Bài này giải thích hơi dài dòng và rất khó hiểu.
- Giống như bạn gunshot9x đã nhận xét rất đúng đắn, chúng ta phải quét dựa vào bán kính. v là những điểm (góc) có bán kính là i.
- Về tam giác vuông (cái mà +180), bạn có thể hiểu đại khái thế này: nếu 2 điểm tạo thành đg` kính đi qua gốc O thì tất cả những điểm nào nằm trên vòng tròn qua 2 điểm đó phải tạo thành tam giác vuông. Nếu có m điểm thì sẽ có m-2 tam giác vuông (vì trừ đi 2 đầu mút cố định).
- Tương tự cho cái +60 và +120.
- mark (cái này hơi thừa, dùng i cũng đc mà). Vòng lặp nó vừa đi vừa đánh dấu, nhưng kết quả chỉ đc tính chỉ sau khi đi qua. Cho đơn giản, giả sử ta chỉ đếm tam giác vuông. Với bán kính i, ta xét v (những điểm cách tâm O là i)
jdkLk8.png

- Khi qua A, nhìn qua E (+180), chưa thấy gì vì E chưa đc đánh dấu (flag[A + 180] = 0). Đánh dấu A.
- Khi qua B, nhìn qua F (+180), chưa thấy gì vì F chưa đc đánh dấu (flag[B + 180] = 0). Đánh dấu B.
- Khi qua C, nhìn ko thấy điểm nào (flag[C + 180] = 0). Đánh dấu C.
- Khi qua D, nhìn qua G (+180), chưa thấy gì vì G chưa đc đánh dấu (flag[D + 180] = 0). Đánh dấu D.
- Khi qua E, nhìn qua A (+180), thấy A, như vậy số tam giác vuông nhận AE là cạnh huyền là 6 (tổng số điểm trừ 2). Đánh dấu E.
- Khi qua F, nhìn qua B (+180), thấy B, như vậy số tam giác vuông nhận FB là cạnh huyền là 6 (tổng số điểm trừ 2). Đánh dấu F.
- Cuối cùng là G tương tự có 6.
[/ah]
'triangles2' thì độ phức tạp ít nhất cũng O(n^2). Vì 'triangles2' chặn hết những trường hợp (cái hay của 'triangles2' là ở phép chặn) nên nó vẫn nhanh. Tuy nhiên, khi n lớn (tới chục nghìn) thì yếu điểm thuật toán O(n^2) ~10^8 bắt đầu thể hiện ra!!!

Nói khó hiểu mọi người nhìn thời gian chạy là biết ngay.
[ah]
ERoK8e.png

[/ah]
Test của mình là full vòng tròn 0-359 với R chạy tăng dần.

@gunshot9x: Trong computer science, 99.99% các bài đều giải đc nếu thời gian và tài nguyên không là vấn đề. Cái chính là làm sao cho nhanh, đó mới là thuật toán. Nếu cái người ta nghĩ ra hay hơn mình thì mình nên học hỏi và ghi nhớ. Đây là cách tôn trọng những người đã dày công nghiên cứu (intellectual property). Ko phải họ chỉ là nghĩ ra mà còn phải chứng minh: tại sao đúng, thời gian chạy ra sao.
 

Sút toàn trật

Ngoan nhất nhà
Em cám ơn anh nhiều nha! Em xem mấy bài trả lời cũng có cảm giác chèo thuyến trong bụng tể tướng vậy.
Mình đã thấy qua nhiều topic rồi và cũng có biết nhiều thành phần tinh tướng và chài cối lắm, tất nhiên cũng có cái miệng, đừng cố tranh luận tranh luận với những thành phần đó làm gì bạn à nên hãy tránh xa thì sẽ tốt hơn, họ cho rằng họ đã thật giỏi không cần học hỏi ở người khác nữa mà cố đem ra bằng chứng để buộc người đó phải thua mình, họ xem đó là sự xỉ nhục mà thôi, hãy cmt với những bạn nào cần hỏi và cần học ở bạn, bạn tengiday mình thấy tham gia diễn đàn này rất lâu và đang sống và làm việc tại mỹ vì khi trước thấy bạn ấy có nói, khi phát ngôn thì bạn cũng thấy rồi đó, rất từ tốn và luôn tôn trọng cmt người khác như vậy là đủ biết tính chất con người như thế nào rồi, tính của bạn rất giống mình, nói nhiều không có nghĩa là họ hiểu nhiều, cái chính là phải có đức tính khiêm tốn, do cũng dốt vấn đề lập trình nên chỉ nói được thế thôi , hơi lạc đề xíu mong mod bỏ qua hoặc xóa cmt này nếu cảm thấy vi phạm chứ đừng ban mình nhé
 
Sút toàn trật: các comment của bạn có vẻ mục đích như đi đá xoáy người khác không có ý xây dựng, trước khi nói người khác hãy ngẫm lại mình trước đi

tengiday: cảm ơn bạn đã đóng góp và giải thích thuật toán đó và mình có thể hiểu cơ bản là như sau

+ thuật toán đó dùng phương pháp liệt kê xét tập nghiệm có cùng trong tập giá trị hay không?

liệt kê tuần tự giá trị bán kính r => rồi tìm tất cả các điểm có cùng bán kính r đang xét => rồi duyệt qua từng PI tính các PI + 180/PI +120 xem điểm đó có tồn tại không, nếu có sẽ nhớ chúng lại

PI + 180: nhớ 2 điểm và chọn điểm thứ 3 từ các điểm còn lại trên miền
PI + 120: nhớ đủ 3 điểm

tập số liệu đầu vào của bạn là fulltest liệt kê toàn bộ tất cả các điểm, do r, PI: nguyên nên ta có miền sau

r = 0 (1 điểm)
r = 1, PI=0 - 359 (360 điểm)
r = 2. PI=0 - 359 (360 điểm)
...
r = n, PI=0 - 359 (360 điểm)

tổng quát miền xét sẽ là n*360 + 1 điểm xét (n[MAX]= 100000 nên sẽ có tối đa 100000*360 + 1 = 36*10^6 + 1 điểm sẽ được liệt kê), việc này sẽ đem lại lợi thế cho thuật toán bạn LanSG9x theo kiểu liệt kê với dữ liệu đầu được khởi tạo liệt kê tuần tự

đối với các dữ liệu sắp xếp ngẫu nhiên, không liên tục thì thuật toán mình có ưu thế hơn

Mình liên tưởng việc nhập dữ liệu đầu vào với việc bạn chấm điểm bút bi lần lượt trên đường tròn đồng tâm từ trong ra ngoài với việc bạn chấm ngẫu nhiên lên các vị trí khác nhau, dữ liệu input thực tế không được lý tưởng như vậy

Tất nhiên phải ghi nhận những thành quả của người đi trước, nhưng cũng không thể sao nhãng các giải pháp cá nhân, nếu không sẽ tự kìm hãm sự phát triển chung.
 
Em mời bạn gunshot9x xem link này khi comment về performance. Bạn bảo rằng đúng k ai tin?
HTML:
https://en.wikipedia.org/wiki/Analysis_of_algorithms
Since different inputs of the same length may cause the algorithm to have different behavior, the function describing its performance is usually an upper bound on the actual performance, determined from the worst case inputs to the algorithm.
Về input thì em thấy anh tengiday chọn test đã "nhẹ" đấy chứ, bạn gunshot9x k nên thử random.
 
@tengiday: Em cám ơn anh đã giải thích. Em cũng k biết giải thuật của nó kĩ lắm. Có lẽ em cần thời gian. Em đã viết nó tựa tựa như thế này. Nhưng k tối ưu anh. Còn cách xa lắm! Cái này là thầy em ghi, mà thầy bảo thầy cũng k biết hết :tuithan:

Em muốn hỏi anh cái này: làm sao anh khai báo mảng số lượng lớn? Em thử mà bị báo overflow. Thầy bảo dùng struct của thầy mới được.
 

Em yêu Vforum

Cần tìm anh trai nuôi :)
Mình liên tưởng việc nhập dữ liệu đầu vào với việc bạn chấm điểm bút bi lần lượt trên đường tròn đồng tâm từ trong ra ngoài với việc bạn chấm ngẫu nhiên lên các vị trí khác nhau, dữ liệu input thực tế không được lý tưởng như vậy
Cần sắp xếp trước khi thực hiện bạn ạ :)
 
Giả sử đầu vào tệ nhất là số lượng điểm xét lớn và sắp xếp ngẫu nhiên

Nếu mà cần sắp xếp thì bạn sao không tính thuật toán sắp xếp vào mức độ phức tạp tổng thể của cả bài toán, vì thuật toán của mình nó dựa trên đầu vào ngẫu nghiên mà không cần sắp xếp lại

Số liêu khởi tạo thử nghiệm fulltest là 1 chuỗi điểm tăng dần (1, 0) => (1, 1) => ... => (1, 359) => (2, 0) => (2, 1) => ... => (2, 359) => ... => (n, 1) => (n, 2) => ... => (n, 359), mình đoán là vậy, vì việc khởi tạo tọa độ điểm tăng dần này rất dễ dàng thay vì tạo ngẫu nhiên một bộ số lớn để test

N = n*360 <=> r = 1 - n, PI = 0 - 359

Việc khởi tạo INPUT ngẫu nhiên không khó, cứ tạo bộ tuần tự tăng dần lưu vào struct (r, PI), rồi cho random hoán vị 2 vị trí ngẫu nhiên, số lần hoán vị thì tùy vào lượng điểm tạo, rồi chỉ in ra 2/3 số điểm đã tạo

ERoK8e.png
 
Các bạn cứ bảo tối ưu mãi. Chạy 1 lệnh với thêm 2 cái lệnh thì có gì khác nhau đâu. Chừng nào chạy 1 lệnh với N lệnh thì mới khác.
Mấy bạn cứ lo mấy cái chi tiết quá. Em thấy vài bài trong box chả thấy mấy bạn comment tối ưu. Ví dụ như thuật toán chạy N^2 với N nè.

aloxinh_nb: trường hợp a == 0 và b != 0, nghiệm là -c/b chứ.

Bác này nói chuẩn.
Lập trình đầu tiên là phải CHẠY ĐƯỢC. Cứ phải chạy được rồi hãy nói tới việc tối ưu.
Vì tối ưu thì phải phải suy nghĩ thế này:

Trường hợp làm với hệ thống lớn: Sẽ phải tối ưu phương thức để hoạt động nhanh. Nhưng đồng nghĩa với đó là code sẽ dài hơn rất là nhiều.
Trường hợp làm với hệ thống nhỏ: Mấy cái chương trình đơn giản hay mấy cái web nhỏ bé xíu thì cứ code thuần, k cần phải mô hình gì cho phức tạp.

Cái vấn đề cần phải nhớ k phải ở tối ưu, mà phải làm nó chạy đúng. Phải tính toán được quy mô hoạt động của ứng dụng. Lúc đó mới tính đến phương án tối ưu.
 
Thầy bảo viết như vầy sẽ test được random điểm. Em thử rồi, cách test này có vẻ chậm hơn.
[ah]
Mã:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <vector>
#include <random>
using namespace std;

int main() {
    printf("             triangles1  \t triangles2\n");
    for (int N = 360; N < 2000000; N *= 2) {
        FILE *f = fopen(FI, "w");

        fprintf(f, "%d\n", N);
        random_device rd_r, rd_theta;
        mt19937 gen_r(rd_r()), gen_theta(rd_theta());
        uniform_int_distribution<unsigned long long> dis_r(1, 99999), dis_theta(0, 359);

        vector<vector<int>> track(100000, vector<int>(360, 0));

        for (int i = 0; i < N; i++) {
            int r, theta;
            do {
                r = dis_r(gen_r);
                theta = dis_theta(gen_theta);
            }
            while (track[r][theta]);
            track[r][theta] = 1;
            fprintf(f, "%d %d\n", r, theta);
        }

        fclose(f);
        
        printf("N = %6d", N);

        clock_t bg = clock();
        triangles1();
        printf("%15.3f", double(clock() - bg) / CLOCKS_PER_SEC);

        bg = clock();
        triangles2();
        printf("%15.3f\n", double(clock() - bg) / CLOCKS_PER_SEC);
    }
}
[/ah]
Đôi khi sắp xếp trước mới xử lí sẽ chạy nhanh hơn.
 
Sửa lần cuối:
Top