Eight

Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 18153 Accepted Submission(s): 4908

Special Judge

Problem Description

The 15-puzzle has been around for over 100 years; even if you don’t know it by that name, you’ve seen it. It is constructed with 15 sliding tiles, each with a number from 1 to 15 on it, and all packed into a 4 by 4 frame with one tile missing. Let’s call the missing tile ‘x’; the object of the puzzle is to arrange the tiles so that they are ordered as:

1 2 3 4

5 6 7 8

9 10 11 12

13 14 15 x

where the only legal operation is to exchange ‘x’ with one of the tiles with which it shares an edge. As an example, the following sequence of moves solves a slightly scrambled puzzle:

1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4

5 6 7 8 5 6 7 8 5 6 7 8 5 6 7 8

9 x 10 12 9 10 x 12 9 10 11 12 9 10 11 12

13 14 11 15 13 14 11 15 13 14 x 15 13 14 15 x

r-> d-> r->

The letters in the previous row indicate which neighbor of the ‘x’ tile is swapped with the ‘x’ tile at each step; legal values are ‘r’,’l’,’u’ and ‘d’, for right, left, up, and down, respectively.

Not all puzzles can be solved; in 1870, a man named Sam Loyd was famous for distributing an unsolvable version of the puzzle, and

frustrating many people. In fact, all you have to do to make a regular puzzle into an unsolvable one is to swap two tiles (not counting the missing ‘x’ tile, of course).

In this problem, you will write a program for solving the less well-known 8-puzzle, composed of tiles on a three by three

arrangement.

Input

You will receive, several descriptions of configuration of the 8 puzzle. One description is just a list of the tiles in their initial positions, with the rows listed from top to bottom, and the tiles listed from left to right within a row, where the tiles are represented by numbers 1 to 8, plus ‘x’. For example, this puzzle

1 2 3

x 4 6

7 5 8

is described by this list:

1 2 3 x 4 6 7 5 8

Output

You will print to standard output either the word “unsolvable”, if the puzzle has no solution, or a string consisting entirely of the letters ‘r’, ‘l’, ‘u’ and ‘d’ that describes a series of moves that produce a solution. The string should include no spaces and start at the beginning of the line. Do not print a blank line between cases.

Sample Input

2 3 4 1 5 x 7 6 8

Sample Output

ullddrurdllurdruldr

解决这道题目，有很多方法，比如双广，BFS打表，A*+简单估价函数，A*+曼哈顿距离，IDA*+曼哈顿距离。但是这些方法都是基于在康托展开的基础上，别的状态表示都会超时。关于康托展开给出一篇博客把

http://blog.csdn.net/Dacc123/article/details/50952079

还有这道题目在poj和hdu上的测试数据是不同的，hdu上的数据比较多吧，poj水一点。

双广，从起始和结尾同时bfs，用康托展开表示状态

hdu看数据的，有的时候是可以过的4960ms。双广还是效率比较低的，poj 188ms

  1. #include <iostream>
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include <algorithm>
  5. #include <math.h>
  6. #include <stdio.h>
  7. #include <queue>
  8. #include <map>
  9. #include <string>
  11. using namespace std;
  12. struct Node
  13. {
  14.     int a[3][3];
  15.     int x,y;
  16.     int state,id;
  17.     Node(){};
  18.     Node(int a[3][3],int x,int y,int state,int id)
  19.     {
  20.         this->id=id;
  21.         this->x=x;
  22.         this->y=y;
  23.         this->state=state;
  24.         memcpy(this->a,a,sizeof(this->a));
  25.     }
  26. };
  27. queue<Node>q;
  28. string f[2][500000];
  29. int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
  30. int fac[10];
  31. int s[2];
  32. char m[2][5]={"udlr","durl"};
  33. char str[105];
  34. void facfun()
  35. {
  37.     fac[0]=1;
  38.     for(int i=1;i<=9;i++)
  39.         fac[i]=fac[i-1]*i;
  40. }
  41. int kangtuo(int a[3][3])
  42. {
  43.     int sum=0,num;
  44.     for(int i=0;i<9;i++)
  45.     {
  46.         num=0;
  47.         for(int j=i+1;j<9;j++)
  48.         {
  49.             if(a[i/3][i%3]>a[j/3][j%3])
  50.                 num++;
  51.         }
  52.         sum+=num*fac[8-i];
  53.     }
  54.     return sum;
  55. }
  56. bool isok(int a[3][3])
  57. {
  58.     int num=0;
  59.     for(int i=0;i<9;i++)
  60.     {
  61.         for(int j=i+1;j<9;j++)
  62.         {
  63.             if(a[i/3][i%3]!=9&&a[j/3][j%3]!=9&&a[i/3][i%3]>a[j/3][j%3])
  64.                 num++;
  65.         }
  66.     }
  67.     return !(num&1);
  68. }
  69. void bfs(Node st,Node ed)
  70.  {
  71.     memset(f,0,sizeof(f));
  72.     q.push(st);q.push(ed);
  73.     s[1]=st.state;s[0]=ed.state;
  74.     f[1][s[1]]="";  f[0][s[0]] = "";
  75.     while(!q.empty())
  76.     {
  77.         Node term=q.front();
  78.         q.pop();
  79.         for(int i=0;i<4;i++)
  80.         {
  81.             int xx=term.x+dir[i][0];
  82.             int yy=term.y+dir[i][1];
  83.             if(xx<0||xx>=3||yy<0||yy>=3)
  84.                 continue;
  85.             swap(term.a[xx][yy],term.a[term.x][term.y]);
  86.             int state=kangtuo(term.a);
  87.             if(!f[term.id][state][0])
  88.             {
  89.                 if(term.id)
  90.                    f[term.id][state]=f[term.id][term.state]+m[term.id][i];
  91.                 else
  92.                      f[term.id][state]=m[term.id][i]+f[term.id][term.state];
  93.                 if(f[1-term.id][state][0])
  94.                 {
  95.                     cout<<f[1][state]<<f[0][state]<<endl;
  96.                     return;
  97.                 }
  98.                 else
  99.                    q.push(Node(term.a,xx,yy,state,term.id));
  100.             }
  102.             swap(term.a[xx][yy],term.a[term.x][term.y]);
  103.         }
  104.     }
  105.     //printf("unsolvable\n");
  106. }
  107. int main()
  108. {
  109.     while(gets(str))
  110.     {
  111.         while(!q.empty())
  112.             q.pop();
  113.         facfun();
  114.         Node st;
  115.         int len=strlen(str);
  116.         int cot=0;
  117.         for(int i=0;i<len;i++)
  118.         {
  119.             if(str[i]!=' ')
  120.             {
  121.                 if(str[i]=='x')
  122.                 {
  123.                     st.a[cot/3][cot%3]=9;
  124.                     st.x=cot/3;st.y=cot%3;
  125.                 }
  126.                 else
  127.                     st.a[cot/3][cot%3]=str[i]-'0';
  128.                 cot++;
  129.             }
  130.         }
  131.         st.id=1;st.state=kangtuo(st.a);
  132.         Node ed;
  133.         cot=1;
  134.         for(int i=0;i<3;i++)
  135.             for(int j=0;j<3;j++)
  136.                 ed.a[i][j]=cot++;
  137.         ed.x=2;ed.y=2;ed.id=0;ed.state=kangtuo(ed.a);
  138.         if(!isok(st.a))
  139.         {
  140.             printf("unsolvable\n");
  141.             continue;
  142.         }
  143.         bfs(st,ed);
  144.     }
  145.     return 0;
  146. }

BFS打表:从结果往前面扫，把每一种状态到结果的步数记录下来。

hdu 109ms poj 989ms

  1. #include <iostream>
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include <algorithm>
  5. #include <math.h>
  6. #include <stdio.h>
  7. #include <map>
  8. #include <queue>
  10. using namespace std;
  11. int fac[]={1,1,2,6,24,120,720,5040,40320};
  12. int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
  13. struct Node
  14. {
  15.     int a[5][5];
  16.     int posx;
  17.     int posy;
  18.     int sta;
  19. };
  20. queue<Node> q;
  21. bool vis[400000];
  22. int res[400000];
  23. int pre[400000];
  24. char s[100];
  25. int a1[100];
  26. int a2[10];
  27. map<int,char>m;
  28. int kt(Node s)
  29. {
  30.     int cot=0;
  31.     for(int i=1;i<=3;i++)
  32.         for(int j=1;j<=3;j++)
  33.             a2[++cot]=s.a[i][j];
  34.     int sum=0,num;
  35.     for(int i=1;i<=9;i++)
  36.     {
  37.         num=0;
  38.         for(int j=i+1;j<=9;j++)
  39.         {
  40.             if(a2[i]>a2[j])
  41.                 num++;
  42.         }
  43.         sum+=num*fac[9-i];
  44.     }
  45.     return sum;
  46. }
  47. void bfs(Node a)
  48. {
  49.     q.push(a);
  50.     vis[0]=1;
  51.     while(!q.empty())
  52.     {
  53.         Node term=q.front();
  54.         q.pop();
  55.         for(int i=0;i<4;i++)
  56.         {
  57.             int xx=term.posx+dir[i][0];
  58.             int yy=term.posy+dir[i][1];
  59.             if(xx<1||xx>3||yy<1||yy>3)
  60.                 continue;
  61.             Node temp=term;
  62.             swap(temp.a[temp.posx][temp.posy],temp.a[xx][yy]);
  63.             temp.posx=xx;temp.posy=yy;
  64.             int state=kt(temp);temp.sta=state;
  65.             if(vis[state])
  66.                 continue;
  67.             pre[state]=term.sta;
  68.             res[state]=i;
  69.             vis[state]=1;
  70.             q.push(temp);
  71.         }
  72.     }
  73. }
  74. void fun(int term)
  75. {
  76.     if(term==0)
  77.         return;
  78.     cout<<m[res[term]];
  79.     fun(pre[term]);
  80. }
  81. int main()
  82. {
  83.     m[0]='u';m[1]='d';m[2]='l';m[3]='r';
  84.     int cnt=1;
  85.     Node t;
  86.     for(int i=1;i<=3;i++)
  87.         for(int j=1;j<=3;j++)
  88.             t.a[i][j]=cnt++;
  89.     t.posx=3;t.posy=3;t.sta=0;
  90.     memset(vis,0,sizeof(vis));
  91.     vis[0]=1;
  92.     bfs(t);
  93.     while(gets(s))
  94.     {
  95.         int x,y;
  96.         int len=strlen(s);
  97.         int cot=0;
  98.         Node t3;
  99.         for(int i=0;i<len;i++)
  100.         {
  101.             if(s[i]!=' ')
  102.             {
  103.                 cot++;
  104.                 if(cot%3==0) { x=cot/3; y=3;}
  105.                 else { x=cot/3+1; y=cot%3;}
  106.                 if(s[i]=='x')
  107.                     t3.a[x][y]=9;
  108.                 else
  109.                     t3.a[x][y]=s[i]-'0';
  110.             }
  111.         }
  113.         int target=kt(t3);
  114.         if(!vis[target])
  115.             printf("unsolvable\n");
  116.         else
  117.         {
  118.             fun(target);
  119.             cout<<endl;
  120.         }
  122.     }
  123.     return 0;
  124. }

A*+简单估价函数+优先队列 ，这里要加一个判断来对应unsolved，当初始状态的逆序数（除去要移动的版块）和目标状态的同偶或同奇，就一定可以到达，否则一定不能。

简单估价函数：可以以当前状态下，多少个数字的位置是不正确的，表示价值。

hdu 2964ms poj 0ms

  1. #include <iostream>
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include <algorithm>
  5. #include <math.h>
  6. #include <queue>
  7. #include <stdio.h>
  8. #include <string>
  9. #include <map>
  11. using namespace std;
  12. #define MAX 400000
  13. struct Node
  14. {
  15.     int a[3][3];//图的状态
  16.     int x,y;//空格的位置
  17.     int state;//康托展开
  18.     int g,h;//估价函数g,h
  19.     string s;//记录路径
  20.     bool operator<(const Node a)const
  21.     {
  22.         return h==a.h?g>a.g:h>a.h;
  23.     }
  24. };
  25. priority_queue<Node> q;
  26. int fac[10];
  27. int vis[MAX+5];
  28. int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
  29. map<int,char> m;
  30. char c[100];
  31. void facfun()
  32. {
  33.     m[0]='d';m[1]='u';m[2]='r';m[3]='l';
  34.     fac[0]=1;
  35.     for(int i=1;i<=9;i++)
  36.         fac[i]=fac[i-1]*i;
  37. }
  38. //康托展开
  39. int kangtuo(int a[3][3])
  40. {
  41.     int sum=0,num;
  42.     for(int i=0;i<9;i++)
  43.     {
  44.         num=0;
  45.         for(int j=i+1;j<9;j++)
  46.         {
  47.             if(a[i/3][i%3]>a[j/3][j%3])
  48.                 num++;
  49.         }
  50.         sum+=num*fac[8-i];
  51.     }
  52.     return sum;
  53. }
  54. //简单估价函数
  55. int get(int a[3][3])
  56. {
  57.     int num=0;
  58.     for(int i=0;i<8;i++)
  59.     {
  60.         if(a[i/3][i%3]!=i+1)
  61.             num++;
  62.     }
  63.     return num;
  64. }
  65. void bfs(Node st)
  66. {
  67.     q.push(st);
  68.     vis[st.state]=1;
  69.     int sh=st.h;int sg=st.g;
  70.     while(!q.empty())
  71.     {
  72.         Node temp;
  73.         Node term=q.top();
  74.         q.pop();
  75.         if(term.state==0)
  76.         {
  77.            cout<<term.s<<endl;
  78.            return;
  79.         }
  80.         for(int i=0;i<4;i++)
  81.         {
  82.             temp=term;
  83.             int xx=temp.x+dir[i][0];
  84.             int yy=temp.y+dir[i][1];
  85.             if(xx<0||xx>2||yy<0||yy>2)
  86.                 continue;
  87.             swap(temp.a[temp.x][temp.y],temp.a[xx][yy]);
  88.             temp.x=xx;temp.y=yy;temp.s=term.s+m[i];
  89.             temp.g=term.g+1;temp.h=get(temp.a);
  90.             temp.state=kangtuo(temp.a);
  91.             if(vis[temp.state])
  92.                 continue;
  94.             vis[temp.state]=1;
  95.             q.push(temp);
  97.         }
  98.     }
  99.     printf("unsolvable\n");
  100. }
  101. bool isok(int a[3][3])
  102. {
  103.     int num=0;
  104.     for(int i=0;i<9;i++)
  105.     {
  106.         for(int j=i+1;j<9;j++)
  107.         {
  108.             if(a[i/3][i%3]!=9&&a[j/3][j%3]!=9&&a[i/3][i%3]>a[j/3][j%3])
  109.                num++;
  110.         }
  111.     }
  112.     if(!(num&1))
  113.         return true;
  114.     else
  115.         return false;
  116. }
  117. int main()
  118. {
  119.     while(gets(c))
  120.     {
  121.         facfun();
  122.         while(!q.empty())
  123.         {
  124.             q.pop();
  125.         }
  126.         memset(vis,0,sizeof(vis));
  127.         int len=strlen(c);
  128.         Node start;
  129.         int cot=0;
  130.         for(int i=0;i<len;i++)
  131.         {
  132.             if(c[i]!=' ')
  133.             {
  134.                 if(c[i]=='x')
  135.                 {
  136.                     start.a[cot/3][cot%3]=9;
  137.                     start.x=cot/3;start.y=cot%3;
  138.                 }
  139.                 else
  140.                     start.a[cot/3][cot%3]=c[i]-'0';
  141.                 cot++;
  142.             }
  143.         }
  144.         start.g=0;start.h=get(start.a);start.state=kangtuo(start.a);
  145.         start.s="";
  146.         if(!isok(start.a))
  147.         {
  148.             printf("unsolvable\n");
  149.             continue;
  150.         }
  152.         bfs(start);
  153.     }
  154.     return 0;
  155. }

A*+曼哈顿距离+优先队列

股价函数变成了曼哈顿距离

hdu 1450ms poj 0ms

  1. #include <iostream>
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include <algorithm>
  5. #include <math.h>
  6. #include <queue>
  7. #include <stdio.h>
  8. #include <string>
  9. #include <map>
  11. using namespace std;
  12. #define MAX 400000
  13. struct Node
  14. {
  15.     int a[3][3];//图的状态
  16.     int x,y;//空格的位置
  17.     int state;//康托展开
  18.     int g,h;//估价函数g,h
  19.     string s;//记录路径
  20.     bool operator<(const Node a)const
  21.     {
  22.         return h==a.h?g>a.g:h>a.h;
  23.     }
  24. };
  25. priority_queue<Node> q;
  26. int fac[10];
  27. int vis[MAX+5];
  28. int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
  29. map<int,char> m;
  30. char c[100];
  31. void facfun()
  32. {
  33.     m[0]='d';m[1]='u';m[2]='r';m[3]='l';
  34.     fac[0]=1;
  35.     for(int i=1;i<=9;i++)
  36.         fac[i]=fac[i-1]*i;
  37. }
  38. //康托展开
  39. int kangtuo(int a[3][3])
  40. {
  41.     int sum=0,num;
  42.     for(int i=0;i<9;i++)
  43.     {
  44.         num=0;
  45.         for(int j=i+1;j<9;j++)
  46.         {
  47.             if(a[i/3][i%3]>a[j/3][j%3])
  48.                 num++;
  49.         }
  50.         sum+=num*fac[8-i];
  51.     }
  52.     return sum;
  53. }
  54. //简单估价函数
  55. int get(int a[3][3])
  56. {
  57.     int num=0;
  58.    for(int i=0;i<3;i++)
  59.    {
  60.        for(int j=0;j<3;j++)
  61.        {
  62.            int x=(a[i][j]-1)/3;
  63.            int y=(a[i][j]-1)%3;
  64.            num+=abs(x-i)+abs(y-j);
  65.        }
  66.    }
  67.     return num;
  68. }
  69. void bfs(Node st)
  70. {
  71.     q.push(st);
  72.     vis[st.state]=1;
  73.     int sh=st.h;int sg=st.g;
  74.     while(!q.empty())
  75.     {
  76.         Node temp;
  77.         Node term=q.top();
  78.         q.pop();
  79.         if(term.state==0)
  80.         {
  81.            cout<<term.s<<endl;
  82.            return;
  83.         }
  84.         for(int i=0;i<4;i++)
  85.         {
  86.             temp=term;
  87.             int xx=temp.x+dir[i][0];
  88.             int yy=temp.y+dir[i][1];
  89.             if(xx<0||xx>2||yy<0||yy>2)
  90.                 continue;
  91.             swap(temp.a[temp.x][temp.y],temp.a[xx][yy]);
  92.             temp.x=xx;temp.y=yy;temp.s=term.s+m[i];
  93.             temp.g=term.g+1;temp.h=get(temp.a);
  94.             temp.state=kangtuo(temp.a);
  95.             if(vis[temp.state])
  96.                 continue;
  98.             vis[temp.state]=1;
  99.             q.push(temp);
  101.         }
  102.     }
  103.     printf("unsolvable\n");
  104. }
  105. bool isok(int a[3][3])
  106. {
  107.     int num=0;
  108.     for(int i=0;i<9;i++)
  109.     {
  110.         for(int j=i+1;j<9;j++)
  111.         {
  112.             if(a[i/3][i%3]!=9&&a[j/3][j%3]!=9&&a[i/3][i%3]>a[j/3][j%3])
  113.                num++;
  114.         }
  115.     }
  116.     if(!(num&1))
  117.         return true;
  118.     else
  119.         return false;
  120. }
  121. int main()
  122. {
  123.     while(gets(c))
  124.     {
  125.         facfun();
  126.         while(!q.empty())
  127.         {
  128.             q.pop();
  129.         }
  130.         memset(vis,0,sizeof(vis));
  131.         int len=strlen(c);
  132.         Node start;
  133.         int cot=0;
  134.         for(int i=0;i<len;i++)
  135.         {
  136.             if(c[i]!=' ')
  137.             {
  138.                 if(c[i]=='x')
  139.                 {
  140.                     start.a[cot/3][cot%3]=9;
  141.                     start.x=cot/3;start.y=cot%3;
  142.                 }
  143.                 else
  144.                     start.a[cot/3][cot%3]=c[i]-'0';
  145.                 cot++;
  146.             }
  147.         }
  148.         start.g=0;start.h=get(start.a);start.state=kangtuo(start.a);
  149.         start.s="";
  150.         if(!isok(start.a))
  151.         {
  152.             printf("unsolvable\n");
  153.             continue;
  154.         }
  156.         bfs(start);
  157.     }
  158.     return 0;
  159. }

HDU 1403 Eight&POJ 1077(康拖，A* ,BFS,双广)的更多相关文章

  1. HDU - 1043 - Eight / POJ - 1077 - Eight

    先上题目: Eight Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Tota ...

  2. hdu 1043 pku poj 1077 Eight (BFS + 康拓展开)

    http://acm.hdu.edu.cn/showproblem.php?pid=1043 http://poj.org/problem?id=1077 Eight Time Limit: 1000 ...

  3. Eight （HDU - 1043|POJ - 1077）(A* | 双向bfs+康拓展开)

    The 15-puzzle has been around for over 100 years; even if you don't know it by that name, you've see ...

  4. HDU 1043 & POJ 1077 Eight（康托展开+BFS+预处理）

    Eight Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 30176   Accepted: 13119   Special ...

  5. HDU 1043 & POJ 1077 Eight（康托展开+BFS | IDA*）

    Eight Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 30176   Accepted: 13119   Special ...

  6. Eight POJ - 1077 HDU - 1043 八数码

    Eight POJ - 1077 HDU - 1043 八数码问题.用hash(康托展开)判重 bfs(TLE) #include<cstdio> #include<iostream ...

  7. HDU 1815， POJ 2749 Building roads（2-sat）

    HDU 1815, POJ 2749 Building roads pid=1815" target="_blank" style="">题目链 ...

  8. HDU 1686 Oulipo / POJ 3461 Oulipo / SCU 2652 Oulipo （字符串匹配，KMP）

    HDU 1686 Oulipo / POJ 3461 Oulipo / SCU 2652 Oulipo (字符串匹配,KMP) Description The French author George ...

  9. HDU 1816， POJ 2723 Get Luffy Out（2-sat)

    HDU 1816, POJ 2723 Get Luffy Out pid=1816" target="_blank" style="">题目链接 ...

随机推荐

  1. LINUX下CPU Load Average的一点研究

    背景: 公司的某个系统工作在基于Linux的Cent OS下,一个host下同时连接了许多client, 最近某台Host总是显示CPU Load Average过高,我们单纯的以为是CPU的占用过高 ...

  2. UVa 10633 - Rare Easy Problem

    题目:给定一个数N.去掉末尾的数变成M.如今已知N-M,确定N. 分析:数论.简单题. 设N = 10*a + b { 当中0 ≤ b ≤ 9 }.则M = a: N - M = N - a = 9* ...

  3. preventDefault

    e.preventDefault()阻止事件默认行为 例如: $("a").click(function (e) {   alert("默认行为被禁止喽"); ...

  4. [转]lsof详解

    lsof是一个功能强大的诊断工具,它可以通过进程与打开的文件进行联系,可以列出一个进程打开的所有文件信息. 1 寻找与打开的文件相关联的进程通过指定文件,可以发现正在使用这个文件的进程# lsof / ...

  5. 详解MathType快捷键使用技巧

    巧妙使用MathType数学公式编辑器可加快数学符号的录入速度和效率,这将节约大量的时间成本,本教程将详解MathType快捷键使用的诸多技巧. 在MathType界面,将鼠标轻轻的放在某个符号上,在 ...

  6. 如何用MathType编辑集合运算符号

    在涉及到集合的运算中,有交并且几种常见的运算,这在数学问题中也是很常见的公式.在用MathType编辑这些符号时,该怎么编辑呢?下面就介绍MathType集合运算符号的编辑方法. 具体操作过程如下: ...

  7. 【Matlab】运动目标检测之“帧差法”

    videoObj = VideoReader('4.avi');%读视频文件 nframes = get(videoObj, 'NumberOfFrames');%获取视频文件帧个数 : nframe ...

  8. 面试题：谈谈如何优化MYSQL数据库查询

    1.优化数据类型 MySQL中数据类型有多种,如果你是一名DBA,正在按照优化的原则对数据类型进行严格的检查,但开发人员可能会选择他们认为最简单的方案,以加快编码速度,或者选择最明显的选择,因此,你可 ...

  9. c语言常用数据类型转换整理

    你要发送原始数据流 还是 格式化输出? 如果是格式化 按原子说的 ,用sprintf / printf; 如果发送原始内存数据流, 可按下面发送, 发送 #define BYTE0(pointer) ...

  10. [转]ASP.NET MVC 5– 使用Wijmo MVC 5模板1分钟创建应用

    开始使用 使用ComponentOne Studio for ASP.NET Wijmo制作MVC5应用程序,首先要做的是安装Studio for ASP.NET Wijmo . 测试环境 VS201 ...