分类目录归档:程序相关

C,Python,环境配置等

Ajax总结

在工作中用了Ajax N多次了,也看过一些相关方面的书籍,也算是认识了它,但是一直没有认真总结和整理过相关的东东,失败!
近有闲情,将之总结如下:

【名称】
Ajax是Asynchronous JavaScript and XML(以及 DHTML 等)的缩写。
详情请移步Ajax: A New Approach to Web Applications

【原理】
简单一些,就是通过使用XmlHttpRequest对象向服务器发送异步请求,获取返回的数据,并使用Javascript和DOM操作页面内的元素,从而达到改变页面内容的目的。
其中XmlHttpRequest对象是关键,因为它支持异步请求。XMLHttpRequest是完全用来向服务器发出一个请求的。它所包含的方法和属性如下所示:
方法:
●abort() 导致当前正在请求被取消
●getAllResponseHeaders() 返回一个字符串,包含氖 响应标头的名称和值
●getResponseHeader(name) 返回指定的响应标头的值
●open(method, url, async, username, password) 设置请求的方法和目标URL。请求可以声明为同步的(可选),也可以给需要基于窗口谁的请求而提供用户名和口令(可选)
●send(content) 发起带有指定内容(可选)的请求
●setRequestHeader(name, value) 利用指定的名称和值,设置一个请求标头

属性:
●onreadystatechange 指派在请求的状态发生变化时所使用的事件处理程序
●readyState 一个整数值,指示请求的状态如下:
0—-未初始化
1—-正在加载
2—-已加载
3—-交互
4—–完成
●responseText 在响应里所返回的内容
●responseXML 如果内容是XML,就根据内容而创建XML DOM
●status 从服务器所返回的响应状态码。例如:200表示成功,404表示未找到,参考HTTP规范
●statusText 响应所返回的状态文本消息

对于此对象其它介绍请移步:XMLHttpRequest概述

【所包含的技术】
· 基于XHTML和CSS标准的表示;
· 使用Document Object Model进行动态显示和交互;
· 使用XMLHttpRequest与服务器进行异步通信;
· 使用JavaScript绑定一切;
· 使用XML和XSLT;交换和操作数据。
以上的技术都是一些广泛使用了的技术,都属于比较旧的技术,ajax是这几种技术的结合体。

【简单实例】

 
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
    <head>
        <title></title>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <script type="text/javascript">
            function ajax() {
                var xmlHttp;
				//	 依据对象判断,而不是依据浏览器
                if(window.XMLHttpRequest)                {
                    xmlHttp=new XMLHttpRequest();//mozilla浏览器
                }else if(window.ActiveXObject){
                    try{
                        xmlHttp=new ActiveXObject("Msxmlx2.XMLHTTP");   //IE老版本
                    }catch(e){}
                    try{
                        xmlHttp=new ActiveXObject("Microsoft.XMLHTTP"); //IE新版本
                    }catch(e){}
 
                    if(!xmlHttp){
                        window.alert("不能创建XMLHttpRequest对象实列");
                        return false;
                    }
                }
 
                if (!xmlHttp) {
                    alert("创建XMLHttpRequest对象失败!");
                    return false;
                }
 
                xmlHttp.open('POST', 'index.php?get_a=2&get_b=3', false);
     xmlHttp.setRequestHeader('Content-type', 'application/x-www-form-urlencoded;charset=UTF-8;');
                xmlHttp.send("post_a=1&post_b=2");
                xmlHttp.onreadystatechange = function() {
                    alert(xmlHttp.readyState);
                }
                if(xmlHttp.readyState == 4){    //判断对象状态
                    var content_obj = document.getElementById("content");
                    content_obj.innerHTML = "正在处理数据...";
                    if(xmlHttp.status == 200){  //信息已经成功返回,开始处理信息
                        var returnStr = xmlHttp.responseText;
                        content_obj.innerHTML =  returnStr;
                    }else{  //页面不正常
                        content_obj.innerHTML = "您所请求的页面存在异常!";
                    }
                }
            }
 
 
        </script>
    </head>
    <body>
        <input type="button" value="ajax" onclick="ajax();" />
        <div id="content">ajax内容显示区</div>
    </body>
</html>

切记:当发起一个POST请求时,需要对报头 Content-type(内容类型)进行设置。这样,服务器就知道如何来处理上传的内容。如果要模拟通过HTTP协议的POST方式来发送表单,则应将内容类型设置为application/x-www-form-urlencoded。

【优点】

●页面无刷新,用户体验好;
●异步,不打断用户操作,响应速度快;
●“按需取数据”,减少冗余请求,减轻服务器负担;
●基于标准化的并被广泛支持的技术,无需额外的插件;
●可以使数据和表现分离;

【存在的问题】
●一些设备还不支持
●开发成本提高
●使back按钮失效,用户操作后无法返回;
●对流媒体支持没有flash之流好;
●对搜索引擎不友好
●破坏程序的异常机制
●存在一些安全问题,暴露了一些程序接口和数据逻辑

棋盘制作

【问题描述 】
国际象棋是世界上最古老的博弈游戏之一,和中国的围棋、象棋以及日本的将棋同享盛名。据说国际象棋起源于易经的思想,棋盘是一个8*8大小的黑白相间的方阵,对应八八六十四卦,黑白对应阴阳。

而我们的主人公小Q,正是国际象棋的狂热爱好者。作为一个顶尖高手,他已不满足于普通的棋盘与规则,于是他跟他的好朋友小W决定将棋盘扩大以适应他们的新规则。

小Q找到了一张由N*M个正方形的格子组成的矩形纸片,每个格子被涂有黑白两种颜色之一。小Q想在这种纸中裁减一部分作为新棋盘,当然,他希望这个棋盘尽可能的大。

不过小Q还没有决定是找一个正方形的棋盘还是一个矩形的棋盘(当然,不管哪种,棋盘必须都黑白相间,即相邻的格子不同色),所以他希望可以找到最大的正方形棋盘面积和最大的矩形棋盘面积,从而决定哪个更好一些。

于是小Q找到了即将参加全国信息学竞赛的你,你能帮助他么?

【输入格式 Input Format 】
第一行包含两个整数N和M,分别表示矩形纸片的长和宽。接下来的N行包含一个N * M的01矩阵,表示这张矩形纸片的颜色(0表示白色,1表示黑色)。

【输出格式 Output Format】
包含两行,每行包含一个整数。第一行为可以找到的最大正方形棋盘的面积,第二行为可以找到的最大矩形棋盘的面积(注意正方形和矩形是可以相交或者包含的)。

【样例输入 Sample Input】
3 3
1 0 1
0 1 0
1 0 0

【样例输出 Sample Output】
4
6

注释 Hint
对于20%的数据,N, M ≤ 80
对于40%的数据,N, M ≤ 400
对于100%的数据,N, M ≤ 2000

算法分析
和盖房子那道题目差不多吧.

正方形是一样的.只不过是重新开始的判断条件不同

长方形记录长和宽就好了.

【代码】

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
#include <stdio.h>
#include <string.h>
#define MAXN 2001
int a[MAXN][MAXN], f[MAXN][MAXN], c[MAXN][MAXN], r[MAXN][MAXN];
 
int min(int t1, int t2)
{
        return t1<t2?t1:t2;
}
 
int main()
{
        int n, m, i, j, k, maxf = 0, maxc = 0, maxr = 0, s1, s2;
 
        scanf("%d%d", &n, &m);
 
        memset(f, 0, sizeof(f));
        memset(c, 0, sizeof(c));
 
        for (i = 1; i <= n; i++)
        {
               for (j = 1; j <= m; j++)
                      scanf("%d", &a[i][j]);
        }
 
        for (i = 1; i<= n; i++)
               f[i][1] = 1;     
 
        for (i = 1; i <= m; i++)
               f[1][i] = 1;
 
        for (i = 2; i <= n; i++)    //求正方形的连长
        {
               for (j = 2; j<= m; j++)
               {
                      if (a[i - 1][j] != a[i][j] && a[i][j - 1] != a[i][j])
                      {
                             f[i][j] = min(f[i - 1][j - 1], min(f[i - 1][j], f[i][j - 1])) + 1;
                      }
                      else
                      {
                             f[i][j] = 1;
                      }
 
                      if (f[i][j] > maxf)
                             maxf = f[i][j];
               }
        }
 
        c[1][1] = 1;    
        r[1][1] = 1;      //长宽初始化
 
        for (i = 2; i <= m; i++)
        {
               if (a[1][i] != a[1][i - 1])
               {
                      c[1][i] = c[1][i - 1] + 1;
               }
               else
                      c[1][i] = 1;
               r[1][i] = 1;
        }
 
        for (i = 2; i <= n; i++)
        {
               if (a[i][1] != a[i - 1][1])
               {
                      r[i][1] = r[i - 1][1] + 1;
               }
               else
                      r[i][1] = 1;
 
               c[i][1] = 1;
        }
 
        for (i = 2; i <= n; i++)
        {
               for (j = 2; j<= m; j++)
               {
                      if (a[i - 1][j] != a[i][j] && a[i][j - 1] != a[i][j])
                      {
                             s1 = min(c[i][j - 1] + 1, c[i - 1][j]) * (r[i - 1][j] + 1);
                             s2 = min(r[i - 1][j] + 1, r[i][j - 1]) * (c[i][j - 1] + 1);
 
                             if (s1 > s2)
                             {
                                    r[i][j] = r[i - 1][j] + 1;
                                    c[i][j] = min(c[i][j - 1] + 1, c[i - 1][j]);
                             }
                             else
                             {
                                    c[i][j] = c[i][j - 1] + 1;
                                    r[i][j] = min(r[i - 1][j] + 1, r[i][j - 1]);
                             }
                      }
                      else
                      {
                             if (a[i - 1][j] != a[i][j])
                             {
                                    r[i][j] = r[i - 1][j] + 1;
                                    c[i][j] = 1;
                             }
                             else if (a[i][j - 1] != a[i][j] )
                             {
                                    r[i][j] = 1;
                                    c[i][j] = c[i][j - 1] + 1;
                             }
                             else
                             {
                                    r[i][j] = 1;
                                    c[i][j] = 1;
                             }
                      }
 
                      if (r[i][j] * c[i][j] > maxr * maxc)
                      {
                             maxr = r[i][j];
                             maxc = c[i][j];
                      }
               }
        }
 
        printf("%d\n%d\n", maxf * maxf, maxr * maxc);
        return 0;
}

盖房子

【问题描述】
永恒の灵魂最近得到了面积为n*m的一大块土地(高兴ING^_^),他想在这块土地上建造一所房子,这个房子必须是正方形的。
但是,这块土地并非十全十美,上面有很多不平坦的地方(也可以叫瑕疵)。这些瑕疵十分恶心,以至于根本不能在上面盖一砖一瓦。
他希望找到一块最大的正方形无瑕疵土地来盖房子。
不过,这并不是什么难题,永恒の灵魂在10分钟内就轻松解决了这个问题。
现在,您也来试试吧。

【输入格式 Input Format】
输入文件第一行为两个整数n,m(1<=n,m<=1000),接下来n行,每行m个数字,用空格隔开。0表示该块土地有瑕疵,1表示该块土地完好。 【输出格式 Output Format】 一个整数,最大正方形的边长。 【样例输入 Sample Input】 4 4 0 1 1 1 1 1 1 0 0 1 1 0 1 1 0 1 【样例输出 Sample Output 】 2 【算法分析】 状态方程就是.f[i,j]=min{f[i-1,j],f[i,j-1],f[i-1,j-1]}+1; f[i,j]表示的是 右下角坐标为(i,j)的正方形边长是f[i,j] 只要从左到右从上到下的2重循环就可以解决叻. 应该容易理解吧. 就贴一下Example Date运行后的F数组值 0 1 1 1 1 1 2 0 0 1 2 0 1 1 0 1 【代码】

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
#include <stdio.h>
#include <string.h>
int a[1002][1002], f[1002][1002];
 
int main()
{
       int i, j, n, m, max = -1;
 
       scanf("%d%d", &n, &m);
       memset(a, 0, sizeof(a));
       memset(f, 0, sizeof(f));
 
       for (i = 1; i <= n; i++)
              for (j = 1; j <= m; j++)
                     scanf("%d", &a[i][j]);
 
              for (i = 1; i <= n; i++)
              {
                     for (j = 1; j <= n; j++)
                     {
                            if (a[i][j] == 1)
                            {
                                          f[i][j] = f[i - 1][j];
                                          if (f[i][j] > f[i][j - 1])
                                                 f[i][j] = f[i][j - 1];
 
                                          if (f[i][j] > f[i - 1][j - 1])
                                                 f[i][j] = f[i - 1][j - 1];
                                          f[i][j] = f[i][j] + 1;
                            }
                            else
                                   f[i][j] = a[i][j];
 
                            if (f[i][j] > max)
                                   max = f[i][j];
                     }
              }
 
              printf("%d\n", max);
              return 0;
}