2017笔试题

1.双链表的反转

---

思路：给定一个双链表的头节点*head，设置两个变量*p,*q,将p=head，
则有，
    q = p->next;
    p->next = p->pre;
    p->pre = q;
重复此操作。

代码如下：

#include<iostream>
using namespace std;
struct  Node
{
    int val;
    Node *next;
    Node *pre;
    Node(int _val) :val(_val),next(NULL),pre(NULL) {};
};
Node *create()
{
    Node *a = new Node(1);
    Node *b = new Node(2);
    Node *c = new Node(3);
    a->next = b;
    b->next = c;
    b->pre = a;
    c->pre = b;
    return a;
}
Node *reverse(Node *head)
{
    Node *p, *q;
    p = head;
    while (p)//逆序
    {
        q = p->next;
        p->next = p->pre;
        p->pre = q;
        p = q;
    }
    return head;//返回尾节点
}
int main() 
{
    Node *head = create();
    Node *head1 = reverse(head);
    cout << head1->pre->val;//测试
    return 0;
}

---

2.判断一个点是否在一个多边形内部

---

假设多边形的坐标存放在一个数组里，首先我们需要取得该数组在横坐标和纵坐标的最大值和最小值，根据这四个点算出一个四边型，首先判断目标坐标点是否在这个四边型之内，如果在这个四边型之外，那可以跳过后面较为复杂的计算，直接返回false。
if (p.x < minX || p.x > maxX || p.y < minY || p.y > maxY) {

 // 这个测试都过不了。。。直接返回false；
 }
 接下来是核心算法部分：

int pnpoly (int nvert, float *vertx, float *verty, float testx, float testy) {

int i, j, c = 0;

for (i = 0, j = nvert-1; i < nvert; j = i++) {

if ( ( (verty[i]>testy) != (verty[j]>testy) ) &&(testx < (vertx[j]-vertx[i]) * (testy-verty[i]) / (verty[j]-verty[i]) + vertx[i]) )

c = !c;

}
return c;
}

额，代码就这么简单，但到底啥意思呢：

首先，参数nvert 代表多边形有几个点。浮点数testx, testy代表待测试点的横坐标和纵坐标，*vertx,*verty分别指向储存多边形横纵坐标数组的首地址。

我们注意到，每次计算都涉及到相邻的两个点和待测试点，然后考虑两个问题：

1 被测试点的纵坐标testy是否在本次循环所测试的两个相邻点纵坐标范围之内？即

verty[i] < testy < verty[j]

或者

verty[j] < testy < verty[i]

2 待测点test是否在i,j两点之间的连线之下？看不懂后半短if statement的朋友请自行在纸上写下i,j两点间的斜率公式，要用到一点初中解析几何和不等式的知识范畴，对广大码农来说小菜一碟。

然后每次这两个条件同时满足的时候我们把返回的布尔量取反。

可这到底是啥意思啊？

这个表达式的意思是说，随便画个多边形，随便定一个点，然后通过这个点水平划一条线，先数数看这条横线和多边形的边相交几次，（或者说先排除那些不相交的边，第一个判断条件），然后再数这条横线穿越多边形的次数是否为奇数，如果是奇数，那么该点在多边形内，如果是偶数，则在多边形外。详细的数学证明这里就不做了，不过读者可以自行画多边形进行验证。

参考地址

---

3.给定一个数n和那个数p1，p2，p3，……，pn，其中qi=pi^(i mod 1)^(i mod 2)^(i mod 3)^……^(i mod n); 求Q=q1^q2^……qn;

---

思路：按照步骤一步一步计算

#include<iostream>
using namespace std;
int main()
{
    int n, res1 = 0, res2 = 0, temp;
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> temp, res1 ^=temp;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
        {
            res2 ^= (i%j);
        }
    cout << (res2^res1);
    return 0;
}

4.给定str1和str2，求最长公共子串

---

思路：采用动态规划，用一个二维数组l[][]存储最大子数组的长度，
则有：
if(str1[i]==str2[j]) l[i][j]=l[i-1][j-1]+1;
else l[i][j]=0;

代码如下：

#include<iostream>
#include<string>
using namespace std;
string maxsubstr(const string& s1, const string &s2)
{
    int len1 = s1.size(), len2 = s2.size();
    int max = 0,w=0;
    int **l = new int*[len1+1];
    for (int i = 0; i < len1+1; i++)
        l[i] = new int[len2+1];
    for (int i = 0; i < len1+1; i++)
        l[i][0] = 0;
    for (int i = 0; i < len2 + 1; i++)
        l[0][i] = 0;
    for (int i = 1; i < len1+1; i++)
        for (int j = 1; j < len2 + 1; j++)
        {
            if (s1[i - 1] == s2[j - 1])
            {
                l[i][j] = l[i - 1][j - 1] + 1;
                if (l[i][j]>max)
                    max = l[i][j], w = i;
            }
            else
                l[i][j] = 0;
        }
    string s;
    for (int i = w - max; i < w; i++)
        s += s1[i];
    return s;
}
int main()
{
    string s1, s2;
    cin >> s1>>s2;
    cout << maxsubstr(s1, s2);
    return 0;
}