免费注册 查看新帖 |

Chinaunix

  平台 论坛 博客 文库
最近访问板块 发新帖

ignore~ this is only for me [复制链接]

论坛徽章:
0
发表于 2013-06-25 17:13 |显示全部楼层
// Swap Nodes in Pairs:


#include <vector>
#include <string>
#include <stack>
#include <algorithm>

using namespace std;
typedef unsigned int uint;

struct ListNode {
        int val;
        ListNode *next;
        ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
public:
        ListNode* swapPairs(ListNode* head)
        {
                if (head == 0 || head->next == 0) return head;
               
                ListNode* pswap = head->next;
                head->next = swapPairs(pswap->next);
                pswap->next = head;
                head = pswap;

                return head;
        }         

};

int main()
{
        ListNode* head = new ListNode(1);
        ListNode* node1 = new ListNode(2);
        ListNode* node2 = new ListNode(3);
        ListNode* node3 = new ListNode(4);
        ListNode* node4 = new ListNode(5);
        ListNode* node5 = new ListNode(6);

        head->next = node1;
        node1->next = node2;
        node2->next = node3;
        node3->next = node4;
        node4->next = node5;


        Solution solve;
        ListNode* ret = solve.swapPairs(head);

        getchar();
        return 0;
}

论坛徽章:
0
发表于 2013-06-26 17:28 |显示全部楼层
//Regular Expression Matching:


#include <vector>
#include <string>
#include <stack>
#include <algorithm>

using namespace std;
typedef unsigned int uint;

class Solution {
public:
        bool isMatch(const char* s, const char* p)
        {
                if (*s == '\0') return true;
                if (isEqual(s, p) && *(p+1) != '*') return isMatch(s+1, p+1);

                if (*(p+1) == '*') {
                        const char* ptr = s;
                        for (; isEqual(ptr, p); ++ptr) {
                                if (isMatch(ptr+1, p+2)) return true;
                        }
                }

                return isMatch(s+1, p+2);
        }         

        bool isEqual(const char* c1, const char* c2)
        {
                return (*c1 == *c2) || (*c1 != '\0' && *c2 == '.');
        }
};

int main()
{
        std::string str1("aaxb");
        std::string str2("c*a*.abb");

        Solution solve;
        bool ret = solve.isMatch(str1.c_str(), str2.c_str());

        getchar();
        return 0;
}

论坛徽章:
0
发表于 2013-06-27 17:19 |显示全部楼层
// Search Insert Position:


#include <vector>
#include <string>
#include <stack>
#include <algorithm>

using namespace std;
typedef unsigned int uint;

class Solution {
public:
        int searchInsert(const int A[], int n, int target)
        {
                if (A[0] > target) return 0;
                if (A[n-1] < target) return n;
                int l = 0;
                int r = n-1;
                while (l <= r) {
                        int mid = (l + r)/2;
                        if (A[mid] == target) return mid;
                        else if (A[mid] < target) {
                                if (A[mid+1] >= target) return mid+1;
                                l = mid+1;
                        } else {
                                if (mid-1 >= 0 && A[mid-1] < target) return mid;
                                r = mid-1;
                        }
                }
        }         
       
};

int main()
{
        int A[] = {1,3,5,6};

        Solution solve;
        int ret = solve.searchInsert(A, sizeof(A)/sizeof(A[0]), 2);

        getchar();
        return 0;
}

论坛徽章:
0
发表于 2013-06-27 20:57 |显示全部楼层
#include <vector>
#include <string>
#include <stack>
#include <algorithm>

using namespace std;
typedef unsigned int uint;

class Solution {
public:
        bool solveSudoku(vector<vector<char>>& board)
        {
                if (board.empty()) return false;
                total = 0;

                return this->solveSudoku_impl(board, 0);
        }         

        int solveSudoku_impl(vector<vector<char>>& board, int id)
        {
                while (id < 81 && board[id/9][id%9] != '.') ++id;
                if (id >= 81) {
                        ++total;


                        for (int i = 0; i < 9; ++i) {
                                for (int j = 0; j < 9; ++i) {
                                        std::cout <<board[i][j] <<'\n'
                                }
                        }

                        return total;
                }

                for (int i = 1; i < 9; ++i) {
                        if (validSudoku(board, id/9, id%9, '0'+i)) {
                                board[id/9][id%9] = '0' + i;
                                if (solveSudoku_impl(board, id+1)) return true;
                        }
                }

                board[id/9][id%9] = '.';
        }
       
        bool validSudoku(vector<vector<char>>& board, int row, int col, char cc)
        {
                for (int i = 0; i < 9; ++i) {
                        if (board[row][i] == cc) return false;
                }

                for (int j = 0; j < 9; ++j) {
                        if (board[j][col] == cc) return false;
                }

                for (int i = 0; i < 3; ++i) {
                        for (int j = 0; j < 3; ++j) {
                                if (board[(row/3)*3 + i][(col/3)*3 + j] == cc) return false;
                        }
                }
        }

private:
        int total;
};

int main()
{
        char puzzle[][9] = {\
        {'.','.','.','5','.','.','.','.','.'}, \
        {'.','1','.','.','.','8','.','.','9'}, \
        {'.','.','4','.','.','.','6','.','.'}, \
        {'.','.','.','8','7','.','.','5','.'}, \
        {'4','.','.','.','.','.','.','.','8'}, \
        {'.','.','.','9','.','1','.','.','3'}, \
        {'.','6','.','.','9','.','2','4','.'}, \
        {'.','.','.','.','.','.','.','7','.'}, \
        {'5','4','2','.','.','.','.','3','.'}  \
    };

        vector<vector<char> > board(9, vector<char> (9, '.'));
        /***
        board.resize(9);
        for (int i = 0; i < 9; ++i)
                for (int j = 0; j < 9; ++j) {
                        board[i].push_back(puzzle[i][j]);
                }
        ***/


        Solution solve;
        int ret = solve.solveSudoku(board);

        getchar();
        return 0;
}

论坛徽章:
0
发表于 2013-07-15 16:26 |显示全部楼层
本帖最后由 楼外青楼山外山 于 2013-07-15 16:27 编辑
  1. class Solution {
  2. public:
  3.     enum Direction {LEFT, DOWN, RIGHT, UP};

  4.         std::vector<std::vector<int>> generateMatrix(int n)
  5.         {
  6.                 if (n < 0) return matrix_;

  7.                 matrix_ = std::vector<std::vector<int>> (n, std::vector<int>(n, -1));
  8.                 isUsed_ = std::vector<std::vector<bool>> (n, std::vector<bool>(n, false));
  9.                 dfs(0, 0, Direction::RIGHT, 1, n*n);
  10.                 return matrix_;
  11.         }

  12.         void dfs(int row, int col, Direction direction, int val, int sum)
  13.         {
  14.                 if (!ValidPlace(row, col)) return;

  15.                 matrix_[row][col] = val;
  16.                 isUsed_[row][col] = true;
  17.                 if (val == sum) return;

  18.                 ++val;
  19.                 if (direction == Direction::RIGHT) {
  20.                         if (ValidPlace(row, col+1) && !isUsed_[row][col+1]) {
  21.                                 dfs(row, col+1, direction, val, sum);
  22.                         } else if (ValidPlace(row+1, col) && !isUsed_[row+1][col]) {
  23.                                 dfs(row+1, col, Direction::DOWN, val, sum);
  24.                         }

  25.                 } else if (direction == Direction::DOWN) {
  26.                         if (ValidPlace(row+1, col) && !isUsed_[row+1][col]) {
  27.                                 dfs(row+1, col, direction, val, sum);
  28.                         } else if (ValidPlace(row, col-1) && !isUsed_[row][col-1]) {
  29.                                 dfs(row, col-1, Direction::LEFT, val, sum);
  30.                         }

  31.                 } else if (direction == Direction::LEFT) {
  32.                         if (ValidPlace(row, col-1) && !isUsed_[row][col-1]) {
  33.                                 dfs(row, col-1, direction, val, sum);
  34.                         } else if (ValidPlace(row-1, col) && !isUsed_[row-1][col]) {
  35.                                 dfs(row-1, col, Direction::UP, val, sum);
  36.                         }

  37.                 } else if (direction == Direction::UP) {
  38.                         if (ValidPlace(row-1, col) && !isUsed_[row-1][col]) {
  39.                                 dfs(row-1, col, direction, val, sum);
  40.                         } else if (ValidPlace(row, col+1) && !isUsed_[row][col+1]) {
  41.                                 dfs(row, col+1, Direction::RIGHT, val, sum);
  42.                         }

  43.                 }
  44.         }

  45.         bool ValidPlace(int row, int col)
  46.         {
  47.                 if (row < 0 || row >= matrix_.size()) return false;
  48.                 if (col < 0 || col >= matrix_[0].size()) return false;

  49.                 return true;
  50.         }

  51. private:
  52.         std::vector<std::vector<int>> matrix_;
  53.         std::vector<std::vector<bool>> isUsed_;
  54. };
复制代码

论坛徽章:
0
发表于 2013-07-16 00:17 |显示全部楼层
  1. #include <vector>
  2. #include <string>
  3. #include <stack>
  4. #include <queue>
  5. #include <set>
  6. #include <algorithm>
  7. #include <unordered_set>
  8. #include <unordered_map>

  9. using namespace std;
  10. typedef unsigned int uint;


  11. class Solution {
  12.         typedef std::vector<std::vector<std::string>> RetVec;
  13.         typedef std::pair<std::string, int> Pair;
  14.         typedef std::unordered_map<std::string, std::unordered_set<std::string>> AdiacencyMap;
  15. public:
  16.          RetVec findLadders(std::string& start, std::string& end, std::unordered_set<std::string>& dict)
  17.         {
  18.                 if (dict.count(start) == 0) dict.insert(start);
  19.                 if (dict.count(end) == 0) dict.insert(end);

  20.                 AdiacencyMap adjacency;
  21.                 buildAdjacency(dict, adjacency);

  22.                 backtrace_.clear();
  23.                 visited_.clear();
  24.                 visited_.insert(start);
  25.                 std::queue<std::string> bsfQue;
  26.                 bsfQue.push(start);
  27.                 int levelCnt = 1;
  28.                 int levels = 0;
  29.                 bool finished = false;
  30.                 while (!bsfQue.empty() && !finished) {
  31.                         int loopCnt = levelCnt;
  32.                         levelCnt = 0;
  33.                         ++levels;
  34.                         for (int i = 0; i < loopCnt; ++i) {
  35.                                 std::string elem = bsfQue.front();
  36.                                 bsfQue.pop();
  37.                                 if (valid(elem, end)) {
  38.                                         backtrace_[end].insert(Pair(elem, levels));
  39.                                         finished = true;
  40.                                         continue;
  41.                                 }

  42.                                 auto iter = adjacency.find(elem);
  43.                                 if (iter == adjacency.end()) continue;

  44.                                 for (auto iterSet = iter->second.begin();
  45.                                                         iterSet != iter->second.end(); ++iterSet)
  46.                                 {
  47.                                         if (visited_.find(*iterSet) == visited_.end()) {
  48.                                                 visited_.insert(*iterSet);
  49.                                                 bsfQue.push(*iterSet);
  50.                                                 ++levelCnt;
  51.                                         }

  52.                                         backtrace_[*iterSet].insert(Pair(elem, levels));
  53.                                 }
  54.                         }
  55.                 }

  56.                 RetVec ret;
  57.                 std::list<std::string> oneSolution;
  58.                 buildPath(ret, oneSolution, start, end, levels);

  59.                 return ret;
  60.         }

  61.         void buildPath(RetVec& ret, std::list<std::string>& oneSolution,
  62.                                         const std::string& start, const std::string& end, int levels)
  63.         {
  64.                 if (start == end) {
  65.                         std::vector<std::string> tmpSolution(oneSolution.begin(), oneSolution.end());
  66.                         ret.push_back(tmpSolution);
  67.                         return;
  68.                 }

  69.                 --levels;
  70.                 for (auto iter = backtrace_[end].begin(); iter != backtrace_[end].end(); ++iter) {
  71.                         if (iter->second == levels) {
  72.                                 oneSolution.push_front(iter->first);
  73.                                 buildPath(ret, oneSolution, start, iter->first, iter->second);
  74.                                 oneSolution.pop_front();
  75.                         }
  76.                 }
  77.         }

  78.         void buildAdjacency(std::unordered_set<std::string>& dict, AdiacencyMap& adjacency)
  79.         {
  80.                 for (auto iter = dict.begin(); iter != dict.end(); ++iter) {
  81.                         std::string elem = *iter;
  82.                         for (uint i = 0; i < elem.size(); ++i) {
  83.                                 for (char cc = 'a'; cc <= 'z'; ++cc) {
  84.                                         if (elem[i] != cc) {
  85.                                                 std::string tmpElem(elem);
  86.                                                 tmpElem[i] = cc;
  87.                                                 if (dict.count(tmpElem)) adjacency[elem].insert(tmpElem);
  88.                                         }
  89.                                 }
  90.                         }
  91.                 }
  92.         }

  93.         bool valid(const string& start, const string& end)
  94.         {
  95.                 if (start.size() != end.size()) return false;

  96.                 int diff = 0;
  97.                 for (int i = 0; i < start.size(); ++i) {
  98.                         if (start[i] != end[i]) ++diff;
  99.                         if (diff > 1) return false;
  100.                 }

  101.                 return diff == 1;
  102.         }

  103. private:
  104.         std::unordered_set<string> visited_;
  105.         std::unordered_map<std::string, std::unordered_set<Pair>> backtrace_;
  106. };

  107. int main()
  108. {
  109.         std::unordered_set<std::string> dict;
  110.         dict.insert("hot");
  111.         dict.insert("dot");
  112.         dict.insert("dog");
  113.         dict.insert("lot");
  114.         dict.insert("hot");
  115.         dict.insert("log");

  116.         Solution solve;
  117.         string start("hit");
  118.         string end("cog");
  119.         std::vector<std::vector<std::string>> ret =
  120.                 solve.findLadders(start, end, dict);

  121.         getchar();
  122.         return 0;
  123. }



复制代码

论坛徽章:
0
发表于 2013-07-16 00:17 |显示全部楼层
#include <vector>
#include <string>
#include <stack>
#include <queue>
#include <set>
#include <algorithm>
#include <unordered_set>
#include <unordered_map>

using namespace std;
typedef unsigned int uint;


class Solution {
        typedef std::vector<std::vector<std::string>> RetVec;
        typedef std::pair<std::string, int> Pair;
        typedef std::unordered_map<std::string, std::unordered_set<std::string>> AdiacencyMap;
public:
         RetVec findLadders(std::string& start, std::string& end, std::unordered_set<std::string>& dict)
        {
                if (dict.count(start) == 0) dict.insert(start);
                if (dict.count(end) == 0) dict.insert(end);

                AdiacencyMap adjacency;
                buildAdjacency(dict, adjacency);

                backtrace_.clear();
                visited_.clear();
                visited_.insert(start);
                std::queue<std::string> bsfQue;
                bsfQue.push(start);
                int levelCnt = 1;
                int levels = 0;
                bool finished = false;
                while (!bsfQue.empty() && !finished) {
                        int loopCnt = levelCnt;
                        levelCnt = 0;
                        ++levels;
                        for (int i = 0; i < loopCnt; ++i) {
                                std::string elem = bsfQue.front();
                                bsfQue.pop();
                                if (valid(elem, end)) {
                                        backtrace_[end].insert(Pair(elem, levels));
                                        finished = true;
                                        continue;
                                }

                                auto iter = adjacency.find(elem);
                                if (iter == adjacency.end()) continue;

                                for (auto iterSet = iter->second.begin();
                                                        iterSet != iter->second.end(); ++iterSet)
                                {
                                        if (visited_.find(*iterSet) == visited_.end()) {
                                                visited_.insert(*iterSet);
                                                bsfQue.push(*iterSet);
                                                ++levelCnt;
                                        }

                                        backtrace_[*iterSet].insert(Pair(elem, levels));
                                }
                        }
                }

                RetVec ret;
                std::list<std::string> oneSolution;
                buildPath(ret, oneSolution, start, end, levels);

                return ret;
        }

        void buildPath(RetVec& ret, std::list<std::string>& oneSolution,
                                        const std::string& start, const std::string& end, int levels)
        {
                if (start == end) {
                        std::vector<std::string> tmpSolution(oneSolution.begin(), oneSolution.end());
                        ret.push_back(tmpSolution);
                        return;
                }

                --levels;
                for (auto iter = backtrace_[end].begin(); iter != backtrace_[end].end(); ++iter) {
                        if (iter->second == levels) {
                                oneSolution.push_front(iter->first);
                                buildPath(ret, oneSolution, start, iter->first, iter->second);
                                oneSolution.pop_front();
                        }
                }
        }

        void buildAdjacency(std::unordered_set<std::string>& dict, AdiacencyMap& adjacency)
        {
                for (auto iter = dict.begin(); iter != dict.end(); ++iter) {
                        std::string elem = *iter;
                        for (uint i = 0; i < elem.size(); ++i) {
                                for (char cc = 'a'; cc <= 'z'; ++cc) {
                                        if (elem[i] != cc) {
                                                std::string tmpElem(elem);
                                                tmpElem[i] = cc;
                                                if (dict.count(tmpElem)) adjacency[elem].insert(tmpElem);
                                        }
                                }
                        }
                }
        }

        bool valid(const string& start, const string& end)
        {
                if (start.size() != end.size()) return false;

                int diff = 0;
                for (int i = 0; i < start.size(); ++i) {
                        if (start[i] != end[i]) ++diff;
                        if (diff > 1) return false;
                }

                return diff == 1;
        }

private:
        std::unordered_set<string> visited_;
        std::unordered_map<std::string, std::unordered_set<Pair>> backtrace_;
};

int main()
{
        std::unordered_set<std::string> dict;
        dict.insert("hot");
        dict.insert("dot");
        dict.insert("dog");
        dict.insert("lot");
        dict.insert("hot");
        dict.insert("log");

        Solution solve;
        string start("hit");
        string end("cog");
        std::vector<std::vector<std::string>> ret =
                solve.findLadders(start, end, dict);

        getchar();
        return 0;
}



论坛徽章:
0
发表于 2013-07-16 18:51 |显示全部楼层
#include <vector>
#include <string>
#include <stack>
#include <queue>
#include <set>
#include <algorithm>
#include <unordered_set>
#include <unordered_map>

using namespace std;
typedef unsigned int uint;


class Solution {
        typedef std::vector<std::vector<std::string>> RetVec;
        typedef std::pair<std::string, int> Pair;
        typedef std::unordered_map<std::string, std::unordered_set<std::string>> AdiacencyMap;
public:
         RetVec findLadders(std::string& start, std::string& end, std::unordered_set<std::string>& dict)
        {
                if (dict.count(start) == 0) dict.insert(start);
                if (dict.count(end) == 0) dict.insert(end);

                AdiacencyMap adjacency;
                buildAdjacency(dict, adjacency);

                backtrace_.clear();
                visited_.clear();
                visited_.insert(start);
                std::queue<std::string> bsfQue;
                bsfQue.push(start);
                int levelCnt = 1;
                int levels = 0;
                bool finished = false;
                while (!bsfQue.empty() && !finished) {
                        int loopCnt = levelCnt;
                        levelCnt = 0;
                        ++levels;
                        for (int i = 0; i < loopCnt; ++i) {
                                std::string elem = bsfQue.front();
                                bsfQue.pop();
                                if (valid(elem, end)) {
                                        backtrace_[end].insert(Pair(elem, levels));
                                        finished = true;
                                        continue;
                                }

                                auto iter = adjacency.find(elem);
                                if (iter == adjacency.end()) continue;

                                for (auto iterSet = iter->second.begin();
                                                        iterSet != iter->second.end(); ++iterSet)
                                {
                                        if (visited_.find(*iterSet) == visited_.end()) {
                                                visited_.insert(*iterSet);
                                                bsfQue.push(*iterSet);
                                                ++levelCnt;
                                        }

                                        backtrace_[*iterSet].insert(Pair(elem, levels));
                                }
                        }
                }

                                ++levels;
                RetVec ret;
                std::list<std::string> oneSolution;
                                oneSolution.push_front(end);
                buildPath(ret, oneSolution, start, end, levels);

                return ret;
        }

        void buildPath(RetVec& ret, std::list<std::string>& oneSolution,
                                        const std::string& start, const std::string& end, int levels)
        {
                if (start == end) {
                        std::vector<std::string> tmpSolution(oneSolution.begin(), oneSolution.end());
                        ret.push_back(tmpSolution);
                        return;
                }

                --levels;
                                if (levels < 0) return;
                for (auto iter = backtrace_[end].begin(); iter != backtrace_[end].end(); ++iter) {
                        if (iter->second == levels) {
                                oneSolution.push_front(iter->first);
                                buildPath(ret, oneSolution, start, iter->first, iter->second);
                                oneSolution.pop_front();
                        }
                }
        }

        void buildAdjacency(std::unordered_set<std::string>& dict, AdiacencyMap& adjacency)
        {
                for (auto iter = dict.begin(); iter != dict.end(); ++iter) {
                        std::string elem = *iter;
                        for (uint i = 0; i < elem.size(); ++i) {
                                for (char cc = 'a'; cc <= 'z'; ++cc) {
                                        if (elem[i] != cc) {
                                                std::string tmpElem(elem);
                                                tmpElem[i] = cc;
                                                if (dict.count(tmpElem)) adjacency[elem].insert(tmpElem);
                                        }
                                }
                        }
                }
        }

        bool valid(const string& start, const string& end)
        {
                if (start.size() != end.size()) return false;

                int diff = 0;
                for (int i = 0; i < start.size(); ++i) {
                        if (start[i] != end[i]) ++diff;
                        if (diff > 1) return false;
                }

                return diff == 1;
        }

                struct hashValue {
                        size_t operator() (const Pair& pair) const {
                                size_t seed = 0;
                                std::hash<std::string> hasher;
                                seed ^= hasher(pair.first) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
                                // seed = std::hash<std::string>()(pair.first);
                                return seed;                       
                        }
                };

                struct keyEqual {
                        bool operator() (const Pair& lhs, const Pair& rhs) const {
                                return lhs.first == rhs.first;
                        }
                };

private:
        std::unordered_set<string> visited_;
                std::unordered_map<std::string, std::unordered_set<Pair, hashValue, keyEqual>> backtrace_;
};

int main()
{
        std::unordered_set<std::string> dict;
        dict.insert("hot");
        dict.insert("dot");
        dict.insert("dog");
        dict.insert("lot");
        dict.insert("hot");
        dict.insert("log");

        Solution solve;
        string start("hit");
        string end("cog");
        std::vector<std::vector<std::string>> ret =
                solve.findLadders(start, end, dict);

        getchar();
        return 0;
}

论坛徽章:
0
发表于 2013-09-06 10:33 |显示全部楼层
class Solution {
public:
        vector<vector<int>> subsets(vector<int>& sub)
        {
                if (sub.empty()) {
                        return vector<vector<int>> ();
                }

                vector<int> result;
                subsetsWithDup_impl(sub, 0, result);
                return subs;
        }

        void subsetsWithDup_impl(vector<int>& sub, int pos,
                vector<int>& result, bool backtrace = false)
        {
                if (pos >= sub.size()) {
                        subs.push_back(result);
                        return;
                }

                subsetsWithDup_impl(sub, pos+1, result);
                result.push_back(sub[pos]);
                subsetsWithDup_impl(sub, pos+1, result);
                result.pop_back();
        }

        vector<vector<int>> subs;
};

论坛徽章:
0
发表于 2013-09-06 10:56 |显示全部楼层
Given a collection of integers that might contain duplicates, S, return all possible subsets.


class Solution {
public:
        vector<vector<int>> subsets(vector<int>& sub)
        {
                if (sub.empty()) {
                        return vector<vector<int>> ();
                }

                std::sort(sub.begin(), sub.end());

                vector<int> result;
                subsetsWithDup_impl(sub, 0, result);
                return subs;
        }

        void subsetsWithDup_impl(vector<int>& sub, int pos,
                vector<int>& result)
        {
                if (pos >= sub.size()) {
                        subs.push_back(result);
                        return;
                }

                result.push_back(sub[pos]);
                subsetsWithDup_impl(sub, pos+1, result);
                result.pop_back();

                for (++pos; pos < sub.size() && sub[pos] == sub[pos-1]; ++pos);
                subsetsWithDup_impl(sub, pos, result);
               
        }

        vector<vector<int>> subs;
};
您需要登录后才可以回帖 登录 | 注册

本版积分规则 发表回复

DTCC2020中国数据库技术大会

【架构革新 高效可控】2020年12月21日-23日第十一届中国数据库技术大会将在北京隆重召开。

大会设置2大主会场,20+技术专场,将邀请超百位行业专家,重点围绕数据架构、AI与大数据、传统企业数据库实践和国产开源数据库等内容展开分享和探讨,为广大数据领域从业人士提供一场年度盛会和交流平台。

http://dtcc.it168.com


大会官网>>
  

北京盛拓优讯信息技术有限公司. 版权所有 16024965号-6 北京市公安局海淀分局网监中心备案编号:11010802020122
中国互联网协会会员  联系我们:huangweiwei@it168.com
感谢所有关心和支持过ChinaUnix的朋友们 转载本站内容请注明原作者名及出处

清除 Cookies - ChinaUnix - Archiver - WAP - TOP