SRM144 DIV1 1100

这是一道很有意思的图论题，分析本问题之前必须先理解一笔画问题的原理，不难扩展出以下定理：

若一个连通无向图的奇顶点个数为n

(1) 当n为0时，图可以一笔画（且可以构造一个回路）

(2) 其他情况，图可以n/2笔画（注意n一定为偶数）

对于多联通分量的无向图，每个联通分量单独计算k笔画的情况，最后累加即可

对于本题，将线段看成图的边，端点和交点看成图的顶点，画n遍转换为每条边重复出现至n次，而：笔抬起的次数=笔画数-1，这样题目就转化为下面这样的问题：

给定一个图，求最少可以几笔画完，每条边不能重复也不能遗漏

模型建好了，但是在编程计算的过程中还有以下难点：

1. 如何处理互有覆盖（overlap）的线段？

题目里已经很清楚的指出覆盖的区域也应该只被画一次，所以必须对这种情况进行处理：将所有有覆盖的线段合并成一个更长的线段，以保证没有任意两条线段再重叠，详见代码。

2. 如何划分出各个联通子图？

按照定理，必须先划分出联通子图分别求解才能计算出总的笔数，不能默认大图一定联通。可以按照基本的图的数据结构来计算，求出所有的交点和端点，判断点和点之间的连接情况，再对图进行一个搜索按连通性对节点进行划分，可想而知这样会相当繁琐。考虑到原图的基本元素就是线段，若划分出了线段也就划分出了联通图，所以可以根据线段的相交情况进行划分，这里需要用到一个数据结构并查集

3. 如何计算每个联通子图的奇顶点的个数？

同上，用基本的图模型来计算是相当繁琐的，考虑到交点的生成受到线段相交性（线段相交的情况）的影响，可以进行如下分析：

两条线段相交只有三种情况：十字交(╋)、丁字交(┳)、端点交(┏)

已知图G和线段L，L不在G中，G的奇顶点个数为odd(G)。

若把L加入到G，L与G的每一次相交都会给odd(G)带来如下变化：╋+0，┳+0，┏-2，同时odd(G)还要加上L的基础量2，即：

\( \begin{equation} \begin{split} odd(G+L) &= 2 + odd(G) + \sum_{相交x} f(x) \end{split} \end{equation} \)

\( f(x) = -2(端点交)  or  0(其他) \)

 实际上，在2中用并查集求联通分量的时候就可以一并把奇顶点个数计算出来，但在配合并查集的时候上述公式需要做一点变换，易推，详见代码。

class UnionSet:
    def __init__(self, segs):
        self.gs = [Graph(seg) for seg in segs]  
        
    def union(self, x, y, q):
        i = self.find(x)
        j = self.find(y)
        if i != j:
            self.gs[i].extend(self.gs[j])
            self.gs[i].oddNodeCount += q + self.gs[j].oddNodeCount
            self.gs.pop(j)
        else:
            self.gs[i].oddNodeCount += q
            
    def find(self, x):
        for i in range(0, len(self.gs)):
            if x in self.gs[i]:
                return i
        raise Exception()
    
    def graphs(self):
        return self.gs
        
        
class Graph(list):

    def __init__(self, seg):
        list.__init__([])
        self.oddNodeCount = 2
        self.append(seg)
        
    def penCount(self, n):
        if n % 2 == 0:
            return 1
        if self.oddNodeCount == 0:
            return 1
        else:
            return int(self.oddNodeCount / 2)
            
            
class Segment:
    def __init__(self, segStr=None, point=None):
        if segStr:
            sp = segStr.split(' ')
            self.x1 = int(sp[0])
            self.y1 = int(sp[1])
            self.x2 = int(sp[2])
            self.y2 = int(sp[3])
        else:
            self.x1 = point[0]
            self.y1 = point[1]
            self.x2 = point[2]
            self.y2 = point[3]
            
        if self.x1 == self.x2:
            self.isHor = False
            if self.y1 > self.y2:
                temp = self.y1
                self.y1 = self.y2
                self.y2 = temp
        else:
            self.isHor = True
            if self.x1 > self.x2:
                temp = self.x1
                self.x1 = self.x2
                self.x2 = temp
        
    def cross(self, seg):
        if self.isHor == seg.isHor:
            return 4
        if self.isHor:
            seg1 = self
            seg2 = seg
        else:
            seg1 = seg
            seg2 = self

        if seg1.x1 <= seg2.x1 <= seg1.x2 and seg2.y1 <= seg1.y1 <= seg2.y2:
            if seg2.x1 in [seg1.x1, seg1.x2] and seg1.y1 in [seg2.y1, seg2.y2]:
                return 3
            elif seg2.x1 in [seg1.x1, seg1.x2] or seg1.y1 in [seg2.y1, seg2.y2]:
                return 2
            else:
                return 1
                
        else:
            return 4

    def isoverlap(self, seg):
        if self.isHor != seg.isHor:
            return False
        if self.isHor and self.y1 == seg.y1:
            return self.x1 <= seg.x1 <= self.x2 or self.x1 <= seg.x2 <= self.x2 or seg.x1 <= self.x1 <= seg.x2 or seg.x1 <= self.x2 <= seg.x2
        elif not self.isHor and self.x1 == seg.x1:
            return self.y1 <= seg.y1 <= self.y2 or self.y1 <= seg.y2 <= self.y2 or seg.y1 <= self.y1 <= seg.y2 or seg.y1 <= self.y2 <= seg.y2

    def overlap(self, seg):
        x1 = min(self.x1, seg.x1, self.x2, seg.x2)
        x2 = max(self.x1, seg.x1, self.x2, seg.x2)
        y1 = min(self.y1, seg.y1, self.y2, seg.y2)
        y2 = max(self.y1, seg.y1, self.y2, seg.y2)
        return Segment(point = (x1,y1,x2,y2))
    
class PenLift:
    def _combineSegments(self, segments):
        ss = [Segment(s) for s in segments]
        i = 0
        while i < len(ss):
            j = i + 1
            while j < len(ss):
                if ss[i].isoverlap(ss[j]):
                    ss[i] = ss[i].overlap(ss[j])
                    ss.pop(j)
                else:
                    j = j + 1
            i = i + 1
        return ss
                
    def numTimes(self, segments, n):
        # 线段排重
        ss = self._combineSegments(segments) # 合并过的线段
        
        # 划分连通图, 直接通过线段计算(并查集)
        # 计算每个连通图点的总度数
        u = UnionSet(ss)

        for i in range(0, len(ss)):
            for j in range(i+1, len(ss)):
                result = ss[i].cross(ss[j])
                if result == 1:
                    #十字交
                    u.union(ss[i], ss[j], 0) 
                elif result == 2:
                    #丁字交
                    u.union(ss[i], ss[j], 0)
                elif result == 3:
                    #端点交
                    u.union(ss[i], ss[j], -2)
                else:
                    #不相交
                    pass

        gs = u.graphs() # 子图

        # 每个连通图分别计算 
        sum = 0
        for g in gs:
            sum += g.penCount(n)
        return sum - 1

代码错了一个点：test case 74，原因不明。以上思路基本应该是正确的，不知道是不是哪种特殊情况没考虑到。