নন-ওভারল্যাপিং বিট ভেক্টরগুলির একটি জোড়া সন্ধান করা

Question

আমি আপনাকে প্রস্থ এর $n$ বিটেক্টরগুলির একটি তালিকা দেব । আপনার লক্ষ্যটি হ'ল তালিকা থেকে দুটি বিটवेকটর ফিরে পাওয়া যার কোনও মিল নেই 1 বা অন্যটি জানাবেন যে এই জাতীয় কোনও জুড়ি নেই।$k$

উদাহরণস্বরূপ, যদি আমি আপনাকে দিতে তারপর একমাত্র সমাধান । বিকল্পভাবে, ইনপুটটির এর কোনও সমাধান নেই। এবং যে কোনও তালিকায় অল-শূন্য বিটভেেক্টর এবং অন্য একটি উপাদান রয়েছে এর একটি তুচ্ছ সমাধান রয়েছে ।$[00110, 01100, 11000]$$\{00110, 11000\}$$[111, 011, 110, 101]$$000...0$$e$$\{e, 000...0\}$

সমাধান না করে এখানে কিছুটা শক্ত উদাহরণ এখানে দেওয়া হয়েছে (প্রতিটি সারিটি কিছুটা ভেক্টর, কালো স্কোয়ারগুলি 1 সে এবং সাদা স্কোয়ার 0 সে):

■ ■ ■ ■ □ □ □ □ □ □ □ □ □
■ □ □ □ ■ ■ ■ □ □ □ □ □ □ 
■ □ □ □ □ □ □ ■ ■ ■ □ □ □
■ □ □ □ □ □ □ □ □ □ ■ ■ ■
□ ■ □ □ □ ■ □ □ □ ■ ■ □ □
□ ■ □ □ ■ □ □ □ ■ □ □ □ ■
□ ■ □ □ □ □ ■ ■ □ □ □ ■ □ <-- All row pairs share a black square
□ □ ■ □ □ □ ■ □ ■ □ ■ □ □
□ □ ■ □ □ ■ □ ■ □ □ □ □ ■
□ □ ■ □ ■ □ □ □ □ ■ □ ■ □
□ □ □ ■ ■ □ □ ■ □ □ ■ □ □
□ □ □ ■ □ □ ■ □ □ ■ □ □ ■
□ □ □ ■ □ ■ □ □ ■ □ □ ■ □

দুটি অ-ওভারল্যাপিং বিটভেটারগুলি কীভাবে দক্ষতার সাথে পাওয়া যায়, বা উপস্থিত নেই তা প্রদর্শিত হয়?

সাদাসিধা অ্যালগরিদম, যেখানে আপনি শুধু প্রতি সম্ভব যুগল তুলনা হয় $O(n^2 k)$ । এটা কি আরও ভাল করা সম্ভব?

Comments

একটি সম্ভাব্য হ্রাস: আপনার প্রতিটি ভেক্টরের জন্য একটি ভার্টেক্স সহ একটি গ্রাফ $G$ এবং দুটি অনুরূপ ভেক্টরগুলির মধ্যে একটি মিল থাকলে দুটি স্তরের মাঝে একটি প্রান্ত রয়েছে। গ্রাফের ব্যাস 2 কিনা তা আপনি জানতে চান $\geq 2$। তবে চেয়ে দ্রুত গতিতে যাওয়া কঠিন বলে মনে হচ্ছে $O(n^2k)$।

— ফ্রান্সোইস

@ ফ্রানয়েসগোডি তিনটি নোড এবং অনুপস্থিত প্রান্ত সহ যে কোনও সংযুক্ত গ্রাফ উপাদানটির ব্যাস কমপক্ষে দুটি হবে। সংলগ্ন তালিকার উপস্থাপনের সাথে এটি পরীক্ষা করতে $O(V)$ সময় লাগে ।

— ক্রেগ গিডনি

@ স্ট্রিল্যাঙ্ক অবশ্যই, যদি গ্রাফটি সম্পূর্ণ না হয় তবে কোনও সমাধান নেই (ব্যাস = 1 এর চেয়ে আরও স্পষ্ট, আপনি ঠিক), তবে সংলগ্ন তালিকার উপস্থাপনাটি দীর্ঘায়িত হতে পারে।

— ফ্রান্সোইস

Is $k$ আপনার মেশিনে বাণী প্রস্থ চেয়ে ছোট?

— রাফেল

@ টমভান্ডারজ্যান্ডেন মনে হচ্ছে এটি আক্রমণকারীদের লঙ্ঘন করবে যে সম্ভবত ডেটা কাঠামো নির্ভর করে। বিশেষত, সেই সাম্যটি ট্রানজিটিভ হওয়া উচিত। আমি ইতিমধ্যে একটি ট্রাই ব্যবহার করার বিষয়ে ভাবছিলাম এবং আমি যখন দেখছি না কীভাবে বিটমাস্কে 0-এর একটি ফ্যাক্টর -2-ব্লুআপটি এড়ানো যায়

— ক্রেগ গিডনি

Answer 1

ওয়ার্মআপ: এলোমেলো বিটেক্টর

একটি ওয়ার্ম-আপ হিসাবে, আমরা প্রতিটি বিটভেক্টর এলোমেলোভাবে একই আইডিকে বেছে নেওয়া হয় সেই ক্ষেত্রে দিয়ে শুরু করতে পারি। তারপরে দেখা যাচ্ছে যে সমস্যাটি $O(n^{1.6} \min(k, \lg n))$ সময়ে সমাধান করা যেতে পারে (আরও স্পষ্টভাবে, এলজি $1.6$ দিয়ে প্রতিস্থাপন করা যেতে পারে )।$\lg 3$

আমরা সমস্যার নিম্নোক্ত দুটি সেট রূপটি বিবেচনা করব:

প্রদত্ত সেটের $S,T \subseteq \{0,1\}^k$ bitvectors এর নির্ধারণ যেখানে অস্তিত্ব আছে একটি অ-ওভারল্যাপিং যুগল $s \in S, t \in T$ ।

এটি সমাধানের প্রাথমিক কৌশলটি হ'ল বিভাজন এবং বিজয়। এখানে একটি সময় বিভাজন এবং বিজয় ব্যবহার করে অ্যালগরিদম রয়েছে:$O(n^{1.6} k)$

1. প্রথম বিট অবস্থানের উপর ভিত্তি করে এবং টি বিভক্ত করুন । অন্য কথায়, ফর্ম S 0 = { গুলি ∈ এস : গুলি 0 = 0 } , S 1 = { গুলি ∈ এস : গুলি 0 = 1 } , টি 0 = { T ∈ টি : T 0 = 0 } , টি 1 = { t ∈ T : $S$$T$$S_0 = \{s \in S : s_0=0\}$$S_1 = \{s \in S : s_0 = 1\}$$T_0 = \{t \in T : t_0 = 0\}$ ।$T_1 = \{t \in T : t_0 = 1\}$

2. এখন পুনরাবৃত্তভাবে , এস 0 , টি 1 এবং টি 1 , এস 0 থেকে একটি নন-ওভারল্যাপিং জুটির সন্ধান করুন । যদি কোনও পুনরাবৃত্তি কল একটি অ-ওভারল্যাপিং জুটি খুঁজে পায়, এটি আউটপুট করুন, অন্যথায় আউটপুট "কোনও ওভারল্যাপিং জুড়ি বিদ্যমান নেই"।$S_0,T_0$$S_0,T_1$$T_1,S_0$

যেহেতু সমস্ত বিটেক্টরগুলি এলোমেলোভাবে বেছে নেওয়া হয়েছে, আমরা আশা করতে পারি এবং | টি খ | ≈ | টি | / 2 । সুতরাং, আমাদের তিনটি পুনরাবৃত্ত কল রয়েছে এবং আমরা দুটির একটি ফ্যাক্টর দ্বারা সমস্যার আকার কমিয়েছি (উভয় সেট দুটির একটি ফ্যাক্টর দ্বারা আকারে হ্রাস করা হয়)। পরে এলজি মিনিট ( | এস | , | টি | ) টুকরা, দুটি সেট এক নিচে আকার 1 হয়, এবং সমস্যা রৈখিক সময় সমাধান করা যেতে পারে। আমরা লাইন বরাবর একটি পুনরাবৃত্তি সম্পর্ক পেতে$|S_b| \approx |S|/2$$|T_b| \approx |T|/2$$\lg \min(|S|,|T|)$ , যার সমাধান টি ( এন ) = ও ( এন 1.6 কে ) । চলমান সময়টির জন্য অ্যাকাউন্টিং হ'ল দ্বি-সেট ক্ষেত্রে সুনির্দিষ্টভাবে চলমান সময় হ'ল হে ( মিনিট ( | এস | , | টি | ) 0.6 সর্বোচ্চ ( | এস | , |$T(n) = 3T(n/2) + O(nk)$$T(n) = O(n^{1.6} k)$ ।$O(\min(|S|,|T|)^{0.6} \max(|S|,|T|) k)$

এটি আরও উন্নত করা যেতে পারে, এটি উল্লেখ করে যে যদি , তবে একটি নন-ওভারল্যাপিং জুটির উপস্থিতি সম্ভাবনাটি খুব অল্প পরিমাণে ছোট। বিশেষ করে, যদি এক্স , Y দুই র্যান্ডম ভেক্টর, সম্ভাব্যতা যে তারা অ ওভারল্যাপিং হয় ( 3 / 4 ) ট । যদি | এস | = | টি | = এন , এরকম এন 2 টি জোড়া রয়েছে, সুতরাং ইউনিয়নের সাথে আবদ্ধ হওয়ার ফলে, একটি নন-ওভারল্যাপিং জুটির উপস্থিতি সম্ভাবনা সর্বাধিক n 2 ( $k \ge 2.5\lg n+100$$x,y$$(3/4)^k$$|S|=|T|=n$$n^2$$n^2 (3/4)^k$. When $k \ge 2.5 \lg n+100$, this is $\le 1/2^{100}$. So, as a pre-processing step, if $k \ge 2.5 \lg n + 100$, then we can immediately return "No non-overlapping pair exists" (the probability this is incorrect is negligibly small), otherwise we run the above algorithm.

এইভাবে আমরা (বা ও ( মিনিট ( | এস | , | টি | )) 0.6 সর্বোচ্চ ( | এস | , | টি | ) মিনিট ( কে , এলজি এন ) এর চলমান সময় অর্জন করি ) ) উপরে প্রস্তাবিত দুটি সেট ভেরিয়েন্টের জন্য), বিশেষ ক্ষেত্রে যেখানে বিটਵੇেক্টরগুলি এলোমেলোভাবে অভিন্নভাবে নির্বাচিত হয়।$O(n^{1.6} \min(k, \lg n))$$O(\min(|S|,|T|)^{0.6} \max(|S|,|T|) \min(k, \lg n))$

Of course, this is not a worst-case analysis. Random bitvectors are considerably easier than the worst case -- but let's treat it as a warmup, to get some ideas that perhaps we can apply to the general case.

Lessons from the warmup

We can learn a few lessons from the warmup above. First, divide-and-conquer (splitting on a bit position) seems helpful. Second, you want to split on a bit position with as many $1$'s in that position as possible; the more $0$'s there are, the less reduction in subproblem size you get.

Third, this suggests that the problem gets harder as the density of $1$'s gets smaller -- if there are very few $1$'s among the bitvectors (they are mostly $0$'s), the problem looks quite hard, as each split reduces the size of the subproblems a little bit. So, define the density $\Delta$ to be the fraction of bits that are $1$ (i.e., out of all $nk$ bits), and the density of bit position $i$ to be the fraction of bitvectors that are $1$ at position $i$.

Handling very low density

As a next step, we might wonder what happens if the density is extremely small. It turns out that if the density in every bit position is smaller than $1/\sqrt{k}$, we're guaranteed that a non-overlapping pair exists: there is a (non-constructive) existence argument showing that some non-overlapping pair must exist. This doesn't help us find it, but at least we know it exists.

Why is this the case? Let's say that a pair of bitvectors $x,y$ is covered by bit position $i$ if $x_i=y_i=1$. Note that every pair of overlapping bitvectors must be covered by some bit position. Now, if we fix a particular bit position $i$, the number of pairs that can be covered by that bit position is at most $(n \Delta(i))^2 < n^2/k$. Summing across all $k$ of the bit positions, we find that the total number of pairs that are covered by some bit position is $< n^2$. This means there must exist some pair that's not covered by any bit position, which implies that this pair is non-overlapping. So if the density is sufficiently low in every bit position, then a non-overlapping pair surely exists.

However, I'm at a loss to identify a fast algorithm to find such a non-overlapping pair, in these regime, even though one is guaranteed to exist. I don't immediately see any techniques that would yield a running time that has a sub-quadratic dependence on $n$. So, this is a nice special case to focus on, if you want to spend some time thinking about this problem.

Towards a general-case algorithm

In the general case, a natural heuristic seems to be: pick the bit position $i$ with the most number of $1$'s (i.e., with the highest density), and split on it. In other words:

1. Find a bit position $i$ that maximizes $\Delta(i)$.

2. $S$$T$$i$$S_0 = \{s \in S : s_i=0\}$, $S_1 = \{s \in S : s_i = 1\}$, $T_0 = \{t \in T : t_i = 0\}$, $T_1 = \{t \in T : t_i = 1\}$.

3. Now recursively look for a non-overlapping pair from $S_0,T_0$, from $S_0,T_1$, and from $T_1,S_0$. If any recursive call finds a non-overlapping pair, output it, otherwise output "No overlapping pair exists".

The challenge is to analyze its performance in the worst case.

Let's assume that as a pre-processing step we first compute the density of every bit position. Also, if $\Delta(i) < 1/\sqrt{k}$ for every $i$, assume that the pre-processing step outputs "An overlapping pair exists" (I realize that this doesn't exhibit an example of an overlapping pair, but let's set that aside as a separate challenge). All this can be done in $O(nk)$ time. The density information can be maintained efficiently as we do recursive calls; it won't be the dominant contributor to running time.

What will the running time of this procedure be? I'm not sure, but here are a few observations that might help. Each level of recursion reduces the problem size by about $n/\sqrt{k}$ bitvectors (e.g., from $n$ bitvectors to $n-n/\sqrt{k}$ bitvectors). Therefore, the recursion can only go about $\sqrt{k}$ levels deep. However, I'm not immediately sure how to count the number of leaves in the recursion tree (there are a lot less than $3^{\sqrt{k}}$ leaves), so I'm not sure what running time this should lead to.

Comments

ad low density: this seems to be some kind of pigeon-hole argument. Maybe if we use your general idea (split w.r.t. the column with the most ones), we get better bounds because the $(S_1, T_1)$-case (we don't recurse to) already gets rid of "most" ones?

— Raphael

The total number of ones may be a useful parameter. You have already shown a lower bound we can use for cutting off the tree; can we show upper bounds, too? For example, if there are more than $ck$ ones, we have at least $c$ overlaps.

— Raphael

By the way, how do you propose we do the first split; arbitrarily? Why not just split the whole input set w.r.t. some column $i$? We only need to recurse in the $0$-case (there is no solution among those that share a one at $i$). In expectation, that gives via $T(n) = T(n/2) + O(nk)$ a bound of $O(nk)$ (if $k$ fixed). For a general bound, you have shown that we can (assuming the lower-bound-cutoff you propose) that we get rid of at least $n/\sqrt{k}$ elements with every split, which seems to imply an $O(nk)$ worst-case bound. Or am I missing something?

— Raphael

Ah, that's wrong, of course, since it does not consider 0-1-mismatches. That's what I get for trying to think before breakfast, I guess.

— Raphael

@Raphael, there are two issues: (a) the vectors might be mostly zeros, so you can't count on getting a 50-50 split; the recurrence would be something more like $T(n) = T((n-n/\sqrt{k})k)+O(nk)$, (b) more importantly, it's not enough to just recurse on the 0-subset; you also need to examine pairings between a vector from the 0-subset and a vector from the 1-subset, so there's an additional recursion or two to do. (I think? I hope I got that right.)

— D.W.

Answer 2

Faster solution when $n \approx k$, using matrix multiplication

Suppose that $n = k$. Our goal is to do better than an $O(n^2k) = O(n^3)$ running time.

We can think of the bitvectors and bit positions as nodes in a graph. There is an edge between a bitvector node and a bit position node when the bitvector has a 1 in that position. The resulting graph is bipartite (with the bitvector-representing nodes on one side and the bitposition-representing nodes on the other), and has $n + k = 2n$ nodes.

Given the adjacency matrix $M$ of a graph, we can tell if there is a two-hop path between two vertices by squaring $M$ and checking if the resulting matrix has an "edge" between those two vertices (i.e. the edge's entry in the squared matrix is non-zero). For our purposes, a zero entry in the squared adjacency matrix corresponds to a non-overlapping pair of bitvectors (i.e. a solution). A lack of any zeroes means there's no solution.

Squaring an n x n matrix can be done in $O(n^\omega)$ time, where $\omega$ is known to be under $2.373$ and conjectured to be $2$.

So the algorithm is:

• Convert the bitvectors and bit positions into a bipartite graph with $n+k$ nodes and at most $nk$ edges. This takes $O(nk)$ time.
• Compute the adjacency matrix of the graph. This takes $O((n+k)^2)$ time and space.
• Square the adjacency matrix. This takes $O((n+k)^\omega)$ time.
• Search the bitvector section of the adjacency matrix for zero entries. This takes $O(n^2)$ time.

The most expensive step is squaring the adjacency matrix. If $n=k$ then the overall algorithm takes $O((n+k)^\omega) = O(n^\omega)$ time, which is better than the naive $O(n^3)$ time.

This solution is also faster when $k$ grows not-too-much-slower and not-too-much-faster than $n$. As long as $k \in \Omega(n^{\omega-2})$ and $k \in O(n^\frac{2}{\omega-1})$, then $(n+k)^\omega$ is better than $n^2 k$. For $w \approx 2.373$ that translates to $n^{0.731} \leq k \leq n^{1.373}$ (asymptotically). If $w$ limits to 2, then the bounds widen towards $n^\epsilon \leq k \leq n^{2-\epsilon}$.

Comments

1. This is also better than the naive solution if $k=\Omega(n)$ but $k=o(n^{1.457})$. 2. If $k \ge n$, a heuristic could be: pick a random subset of $n$ bit positions, restrict to those bit positions and use matrix multiplication to enumerate all pairs that don't overlap in those $n$ bit positions; for each such pair, check if it solves the original problem. If there aren't many pairs that don't overlap in those $n$ bit positions, this provides a speedup over the naive algorithm. However I don't know a good upper bound on the number of such pairs.

— D.W.

Answer 3

This is equivalent to finding a bit vector which is a subset of the complement of another vector; ie its 1's occur only where 0's occur in the other.

If k (or the number of 1's) is small, you can get $O(n2^k)$ time by simply generating all the subsets of the complement of each bitvector and putting them in a trie (using backtracking). If a bitvector is found in the trie (we can check each before complement-subset insertion) then we have a non-overlapping pair.

If the number of 1's or 0's is bounded to an even lower number than k, then the exponent can be replaced by that. The subset-indexing can be on either each vector or its complement, so long as probing uses the opposite.

There's also a scheme for superset-finding in a trie that only stores each vector only once, but does bit-skipping during probes for what I believe is similar aggregate complexity; ie it has $o(k)$ insertion but $o(2^k)$ searches.

Comments

thanks. The complexity of your solution is $\sim n 2^{(1-p)k}$, where $p$ is the probability of 1's in the bitvector. A couple of implementation details: though this is a slight improvement, there's no need to compute and store the complements in the trie. Just following the complementary branches when checking for a non-overlapping match is enough. And, taking the 0's directly as wildcards, no special wildcard is needed, either.

— Mauro Lacy

Answer 4

Represent the bit vectors as an $n\times k$ matrix $M$. Take $i$ and $j$ between 1 and $n$.

$$\begin{align} (MM^T)_{ij} = \sum_l M_{il}M_{jl} \end{align}.$$

$(MM^T)_{ij}$, the dot product of the $i$th and $j$th vector, is non-zero if, and only if, vectors $i$ and $j$ share a common 1. So, to find a solution, compute $MM^T$ and return the position of a zero entry, if such an entry exists.

Complexity

Using naive multiplication, this requires $O(n^2k)$ arithmetic operations. If $n=k$, it takes $O(n^{2.37})$ operations using the utterly impractical Coppersmith-Winograd algorithm, or $O(n^{2.8})$ using the Strassen algorithm. If $k=O(n^{0.302})$, then the problem may be solved using $n^{2 + o(1)}$ operations.

Comments

How is this different from Strilanc's answer?

— D.W.

@D.W. Using an $n$-by-$k$ matrix instead of an $(n+k)$-by-$(n+k)$ matrix is an improvement. Also it mentions a way to cut off the factor of k when k << n, so that might be useful.

— Craig Gidney