#include <iostream>
#include <vector>
 
int main() {
    // 創(chuàng)建一個(gè)大小為10000的整數(shù)向量
    std::vector<int> vec(10000);
 
    // 初始化向量
    for (int i = 0; i < 10000; ++i) {
        vec[i] = i;
    }
 
    // 計(jì)算向量中所有元素的和
    int sum = 0;
    for (int i = 0; i < 10000; ++i) {
        // 利用時(shí)間局部性：sum變量在循環(huán)中被反復(fù)使用，因此可能會(huì)被緩存在CPU緩存中
        sum += vec[i];
    }
 
    std::cout << "Sum: " << sum << std::endl;
 
    return 0;
}

#include <iostream>
#include <vector>
 
const int N = 1000;
 
// 矩陣相乘函數(shù)
void matrixMultiplication(const std::vector<std::vector<int>>& matrixA,
                          const std::vector<std::vector<int>>& matrixB,
                          std::vector<std::vector<int>>& result) {
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            // 利用時(shí)間局部性：result[i][j] 在循環(huán)中被頻繁使用
            int sum = 0;
            for (int k = 0; k < N; ++k) {
                // 利用空間局部性：matrixA[i][k] 和 matrixB[k][j] 可能會(huì)被緩存在CPU緩存中
                sum += matrixA[i][k] * matrixB[k][j];
            }
            result[i][j] = sum;
        }
    }
}
 
int main() {
    // 創(chuàng)建并初始化矩陣
    std::vector<std::vector<int>> matrixA(N, std::vector<int>(N, 1));
    std::vector<std::vector<int>> matrixB(N, std::vector<int>(N, 2));
    std::vector<std::vector<int>> result(N, std::vector<int>(N));
 
    // 計(jì)算矩陣相乘
    matrixMultiplication(matrixA, matrixB, result);
 
    // 輸出結(jié)果
    std::cout << "Result:" << std::endl;
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            std::cout << result[i][j] << " ";
        }
        std::cout << std::endl;
    }
 
    return 0;
}

#include <iostream>
#include <vector>
 
// 定義一個(gè)結(jié)構(gòu)體表示學(xué)生信息
struct Student {
    int id;
    char name[20];
    int age;
};
 
int main() {
    const int numStudents = 1000;
    std::vector<Student> students(numStudents);
 
    // 初始化學(xué)生信息
    for (int i = 0; i < numStudents; ++i) {
        students[i].id = i + 1;
        sprintf(students[i].name, "Student%d", i + 1);
        students[i].age = 20 + i % 5;
    }
 
    // 計(jì)算所有學(xué)生的平均年齡
    int totalAge = 0;
    for (int i = 0; i < numStudents; ++i) {
        // 利用局部性原理：緊密相關(guān)的數(shù)據(jù)(id, name, age)被連續(xù)地存儲(chǔ)在內(nèi)存中
        totalAge += students[i].age;
    }
    double averageAge = static_cast<double>(totalAge) / numStudents;
 
    std::cout << "Average Age: " << averageAge << std::endl;
 
    return 0;
}

#include <iostream>
#include <vector>
 
// 使用動(dòng)態(tài)規(guī)劃計(jì)算斐波那契數(shù)列的第n項(xiàng)
int fibonacci(int n) {
    std::vector<int> fib(n + 1);
 
    // 初始化前兩個(gè)斐波那契數(shù)
    fib[0] = 0;
    fib[1] = 1;
 
    // 計(jì)算斐波那契數(shù)列的每一項(xiàng)
    for (int i = 2; i <= n; ++i) {
        // 利用空間局部性：fib[i-1] 和 fib[i-2] 可能會(huì)被緩存在CPU緩存中
        fib[i] = fib[i - 1] + fib[i - 2];
    }
 
    return fib[n];
}
 
int main() {
    int n = 10;
    int result = fibonacci(n);
    std::cout << "Fibonacci(" << n << ") = " << result << std::endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <chrono>
 
const int N = 1000; // 矩陣維度
 
// 矩陣相乘函數(shù)，使用分塊優(yōu)化
void matrixMultiplication(const std::vector<std::vector<int>>& matrixA,
                          const std::vector<std::vector<int>>& matrixB,
                          std::vector<std::vector<int>>& result) {
    const int blockSize = 32; // 分塊大小，根據(jù)CPU緩存大小和關(guān)聯(lián)性調(diào)整
 
    for (int i = 0; i < N; i += blockSize) {
        for (int j = 0; j < N; j += blockSize) {
            for (int k = 0; k < N; k += blockSize) {
                // 分塊計(jì)算
                for (int ii = i; ii < std::min(i + blockSize, N); ++ii) {
                    for (int jj = j; jj < std::min(j + blockSize, N); ++jj) {
                        int sum = 0;
                        for (int kk = k; kk < std::min(k + blockSize, N); ++kk) {
                            sum += matrixA[ii][kk] * matrixB[kk][jj];
                        }
                        result[ii][jj] += sum;
                    }
                }
            }
        }
    }
}
 
int main() {
    std::vector<std::vector<int>> matrixA(N, std::vector<int>(N, 1)); // 初始化矩陣A
    std::vector<std::vector<int>> matrixB(N, std::vector<int>(N, 2)); // 初始化矩陣B
    std::vector<std::vector<int>> result(N, std::vector<int>(N, 0)); // 結(jié)果矩陣
 
    auto start = std::chrono::steady_clock::now();
 
    // 計(jì)算矩陣相乘
    matrixMultiplication(matrixA, matrixB, result);
 
    auto end = std::chrono::steady_clock::now();
    std::chrono::duration<double> elapsed_seconds = end - start;
    std::cout << "Time taken: " << elapsed_seconds.count() << "s" << std::endl;
 
    return 0;
}

#include <iostream>
#include <vector>
 
const int ROWS = 1000;
const int COLS = 1000;
 
// 使用行優(yōu)先存儲(chǔ)順序的二維數(shù)組遍歷函數(shù)
void traverseArray(std::vector<std::vector<int>>& array) {
    int sum = 0;
    // 外層循環(huán)遍歷行
    for (int i = 0; i < ROWS; ++i) {
        // 內(nèi)層循環(huán)遍歷列
        for (int j = 0; j < COLS; ++j) {
            // 利用局部性原理：按行連續(xù)訪問數(shù)組元素，提高緩存命中率
            sum += array[i][j];
        }
    }
    std::cout << "Sum: " << sum << std::endl;
}
 
int main() {
    // 創(chuàng)建一個(gè)二維數(shù)組并初始化
    std::vector<std::vector<int>> array(ROWS, std::vector<int>(COLS));
    for (int i = 0; i < ROWS; ++i) {
        for (int j = 0; j < COLS; ++j) {
            array[i][j] = i * COLS + j;
        }
    }
 
    // 調(diào)用遍歷數(shù)組的函數(shù)
    traverseArray(array);
 
    return 0;
}

#include <iostream>
#include <vector>
 
// 基于數(shù)組的棧實(shí)現(xiàn)
class ArrayStack {
private:
    std::vector<int> data; // 使用數(shù)組存儲(chǔ)棧元素
public:
    // 入棧操作
    void push(int val) {
        data.push_back(val); // 將元素添加到數(shù)組末尾
    }
 
    // 出棧操作
    int pop() {
        if (data.empty()) {
            std::cerr << "Error: Stack is empty!" << std::endl;
            return -1; // 出錯(cuò)時(shí)返回-1
        }
        int topVal = data.back(); // 獲取棧頂元素
        data.pop_back(); // 刪除棧頂元素
        return topVal;
    }
 
    // 判斷棧是否為空
    bool isEmpty() {
        return data.empty();
    }
};
 
int main() {
    // 創(chuàng)建基于數(shù)組的棧對象
    ArrayStack stack;
 
    // 入棧操作
    stack.push(10);
    stack.push(20);
    stack.push(30);
 
    // 出棧操作
    std::cout << stack.pop() << std::endl; // 應(yīng)輸出30
    std::cout << stack.pop() << std::endl; // 應(yīng)輸出20
    std::cout << stack.pop() << std::endl; // 應(yīng)輸出10
 
    // 嘗試從空棧中彈出元素
    std::cout << stack.pop() << std::endl; // 應(yīng)輸出錯(cuò)誤信息
 
    return 0;
}