Minimizing the distance between points in two sets












5












$begingroup$


Given two sets $A, Bsubset mathbb{N}^2$, each with finite cardinality, what's the most efficient algorithm to compute $min_{uin A, vin B}d(u, v)$ where $d(u,v)$ is the (Euclidean) distance between $u$ and $v$ (may be considered as points or vectors). Also what's the most efficient algorithm to determine $u$ and $v$ (not necessarily unique) such that $d(u,v)$ is minimized?




So minimizing $d(u,v)$ is pretty much the same as minimizing $[d(u,v)]^2$, which can be written using the distance formula. But I couldn't think of anything better than a brute-force $O(|A||B|)$ solution (where $|A|$ denotes the cardinality of $A$) which tries every possible $uin A,vin B$.






algorithms optimization computer-science contest-math linear-programming







share|cite|improve this question









$endgroup$

















    5












    $begingroup$


    Given two sets $A, Bsubset mathbb{N}^2$, each with finite cardinality, what's the most efficient algorithm to compute $min_{uin A, vin B}d(u, v)$ where $d(u,v)$ is the (Euclidean) distance between $u$ and $v$ (may be considered as points or vectors). Also what's the most efficient algorithm to determine $u$ and $v$ (not necessarily unique) such that $d(u,v)$ is minimized?




    So minimizing $d(u,v)$ is pretty much the same as minimizing $[d(u,v)]^2$, which can be written using the distance formula. But I couldn't think of anything better than a brute-force $O(|A||B|)$ solution (where $|A|$ denotes the cardinality of $A$) which tries every possible $uin A,vin B$.






    algorithms optimization computer-science contest-math linear-programming







    share|cite|improve this question









    $endgroup$















      5












      5








      5


      1



      $begingroup$


      Given two sets $A, Bsubset mathbb{N}^2$, each with finite cardinality, what's the most efficient algorithm to compute $min_{uin A, vin B}d(u, v)$ where $d(u,v)$ is the (Euclidean) distance between $u$ and $v$ (may be considered as points or vectors). Also what's the most efficient algorithm to determine $u$ and $v$ (not necessarily unique) such that $d(u,v)$ is minimized?




      So minimizing $d(u,v)$ is pretty much the same as minimizing $[d(u,v)]^2$, which can be written using the distance formula. But I couldn't think of anything better than a brute-force $O(|A||B|)$ solution (where $|A|$ denotes the cardinality of $A$) which tries every possible $uin A,vin B$.






      algorithms optimization computer-science contest-math linear-programming







      share|cite|improve this question









      $endgroup$




      Given two sets $A, Bsubset mathbb{N}^2$, each with finite cardinality, what's the most efficient algorithm to compute $min_{uin A, vin B}d(u, v)$ where $d(u,v)$ is the (Euclidean) distance between $u$ and $v$ (may be considered as points or vectors). Also what's the most efficient algorithm to determine $u$ and $v$ (not necessarily unique) such that $d(u,v)$ is minimized?




      So minimizing $d(u,v)$ is pretty much the same as minimizing $[d(u,v)]^2$, which can be written using the distance formula. But I couldn't think of anything better than a brute-force $O(|A||B|)$ solution (where $|A|$ denotes the cardinality of $A$) which tries every possible $uin A,vin B$.






      algorithms optimization computer-science contest-math linear-programming




      algorithms optimization computer-science contest-math linear-programming






      share|cite|improve this question













      share|cite|improve this question











      share|cite|improve this question




      share|cite|improve this question










      asked Dec 17 '13 at 7:22









      Christmas BunnyChristmas Bunny

      2,3421028




      2,3421028






















          1 Answer
          1






          active

          oldest

          votes


















          0












          $begingroup$

          Here's an $O(n log n)$ algorithm that works for all possible sets $A$ and $B$.



          Let $n = |A| + |B|$.



          This question has been asked in other platforms (here or here), but none of them give satisfactory answers (...at least to me. I cannot verify that they work in the claimed time for all possible inputs. For example, using KD tree does not guarantee $O(n log n)$ unless the points are sufficiently random. The answer to second link is even more evil).



          So, here's a purely $O(n log n)$ algorithm to solve this! Good thing you asked this in a math forum, because despite being theoretically interesting, I wouldn't want to implement it...



          First, construct the voronoi diagram $V_A$ of all the points in $A$. For each point $b_j in B$, find the voronoi cell $v_i in V_A$ that contains the point -- by the property of a voronoi diagram, we know that $a_i$ is the closest neighbor of $b_j$. Thus, by doing this for all points in $B$ and taking the minimum, we get the pair with minimum distance.



          Of course, that's assuming we are able to find the cell $v_i$ for each point $b_i$ quickly. To do it quickly, we use the sweep line algorithm: sweep all the points in the voronoi diagram $V_A$ and the points $B$. We store the current partition of the space using a binary tree so that whenever the sweep line encounters a point $b_i in B$, we are able to find the voronoi diagram containing $b_i$ in $O(log n)$. Whenever we encounter a point $a_i in A$, we update the tree from the structure of the voronoi diagram. This sweep line is rather analogous to the sweep line performed for the "find intersecting lines" algorithm.



          Since construction of a voronoi diagram takes $O(n log n)$ time, the entire procedure is $O(n log n)$.






          share|cite|improve this answer











          $endgroup$













            Your Answer





            StackExchange.ifUsing("editor", function () {
            return StackExchange.using("mathjaxEditing", function () {
            StackExchange.MarkdownEditor.creationCallbacks.add(function (editor, postfix) {
            StackExchange.mathjaxEditing.prepareWmdForMathJax(editor, postfix, [["$", "$"], ["\\(","\\)"]]);
            });
            });
            }, "mathjax-editing");

            StackExchange.ready(function() {
            var channelOptions = {
            tags: "".split(" "),
            id: "69"
            };
            initTagRenderer("".split(" "), "".split(" "), channelOptions);

            StackExchange.using("externalEditor", function() {
            // Have to fire editor after snippets, if snippets enabled
            if (StackExchange.settings.snippets.snippetsEnabled) {
            StackExchange.using("snippets", function() {
            createEditor();
            });
            }
            else {
            createEditor();
            }
            });

            function createEditor() {
            StackExchange.prepareEditor({
            heartbeatType: 'answer',
            autoActivateHeartbeat: false,
            convertImagesToLinks: true,
            noModals: true,
            showLowRepImageUploadWarning: true,
            reputationToPostImages: 10,
            bindNavPrevention: true,
            postfix: "",
            imageUploader: {
            brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
            contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
            allowUrls: true
            },
            noCode: true, onDemand: true,
            discardSelector: ".discard-answer"
            ,immediatelyShowMarkdownHelp:true
            });


            }
            });














            draft saved

            draft discarded


















            StackExchange.ready(
            function () {
            StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fmath.stackexchange.com%2fquestions%2f610098%2fminimizing-the-distance-between-points-in-two-sets%23new-answer', 'question_page');
            }
            );

            Post as a guest















            Required, but never shown

























            1 Answer
            1






            active

            oldest

            votes








            1 Answer
            1






            active

            oldest

            votes









            active

            oldest

            votes






            active

            oldest

            votes









            0












            $begingroup$

            Here's an $O(n log n)$ algorithm that works for all possible sets $A$ and $B$.



            Let $n = |A| + |B|$.



            This question has been asked in other platforms (here or here), but none of them give satisfactory answers (...at least to me. I cannot verify that they work in the claimed time for all possible inputs. For example, using KD tree does not guarantee $O(n log n)$ unless the points are sufficiently random. The answer to second link is even more evil).



            So, here's a purely $O(n log n)$ algorithm to solve this! Good thing you asked this in a math forum, because despite being theoretically interesting, I wouldn't want to implement it...



            First, construct the voronoi diagram $V_A$ of all the points in $A$. For each point $b_j in B$, find the voronoi cell $v_i in V_A$ that contains the point -- by the property of a voronoi diagram, we know that $a_i$ is the closest neighbor of $b_j$. Thus, by doing this for all points in $B$ and taking the minimum, we get the pair with minimum distance.



            Of course, that's assuming we are able to find the cell $v_i$ for each point $b_i$ quickly. To do it quickly, we use the sweep line algorithm: sweep all the points in the voronoi diagram $V_A$ and the points $B$. We store the current partition of the space using a binary tree so that whenever the sweep line encounters a point $b_i in B$, we are able to find the voronoi diagram containing $b_i$ in $O(log n)$. Whenever we encounter a point $a_i in A$, we update the tree from the structure of the voronoi diagram. This sweep line is rather analogous to the sweep line performed for the "find intersecting lines" algorithm.



            Since construction of a voronoi diagram takes $O(n log n)$ time, the entire procedure is $O(n log n)$.






            share|cite|improve this answer











            $endgroup$


















              0












              $begingroup$

              Here's an $O(n log n)$ algorithm that works for all possible sets $A$ and $B$.



              Let $n = |A| + |B|$.



              This question has been asked in other platforms (here or here), but none of them give satisfactory answers (...at least to me. I cannot verify that they work in the claimed time for all possible inputs. For example, using KD tree does not guarantee $O(n log n)$ unless the points are sufficiently random. The answer to second link is even more evil).



              So, here's a purely $O(n log n)$ algorithm to solve this! Good thing you asked this in a math forum, because despite being theoretically interesting, I wouldn't want to implement it...



              First, construct the voronoi diagram $V_A$ of all the points in $A$. For each point $b_j in B$, find the voronoi cell $v_i in V_A$ that contains the point -- by the property of a voronoi diagram, we know that $a_i$ is the closest neighbor of $b_j$. Thus, by doing this for all points in $B$ and taking the minimum, we get the pair with minimum distance.



              Of course, that's assuming we are able to find the cell $v_i$ for each point $b_i$ quickly. To do it quickly, we use the sweep line algorithm: sweep all the points in the voronoi diagram $V_A$ and the points $B$. We store the current partition of the space using a binary tree so that whenever the sweep line encounters a point $b_i in B$, we are able to find the voronoi diagram containing $b_i$ in $O(log n)$. Whenever we encounter a point $a_i in A$, we update the tree from the structure of the voronoi diagram. This sweep line is rather analogous to the sweep line performed for the "find intersecting lines" algorithm.



              Since construction of a voronoi diagram takes $O(n log n)$ time, the entire procedure is $O(n log n)$.






              share|cite|improve this answer











              $endgroup$
















                0












                0








                0





                $begingroup$

                Here's an $O(n log n)$ algorithm that works for all possible sets $A$ and $B$.



                Let $n = |A| + |B|$.



                This question has been asked in other platforms (here or here), but none of them give satisfactory answers (...at least to me. I cannot verify that they work in the claimed time for all possible inputs. For example, using KD tree does not guarantee $O(n log n)$ unless the points are sufficiently random. The answer to second link is even more evil).



                So, here's a purely $O(n log n)$ algorithm to solve this! Good thing you asked this in a math forum, because despite being theoretically interesting, I wouldn't want to implement it...



                First, construct the voronoi diagram $V_A$ of all the points in $A$. For each point $b_j in B$, find the voronoi cell $v_i in V_A$ that contains the point -- by the property of a voronoi diagram, we know that $a_i$ is the closest neighbor of $b_j$. Thus, by doing this for all points in $B$ and taking the minimum, we get the pair with minimum distance.



                Of course, that's assuming we are able to find the cell $v_i$ for each point $b_i$ quickly. To do it quickly, we use the sweep line algorithm: sweep all the points in the voronoi diagram $V_A$ and the points $B$. We store the current partition of the space using a binary tree so that whenever the sweep line encounters a point $b_i in B$, we are able to find the voronoi diagram containing $b_i$ in $O(log n)$. Whenever we encounter a point $a_i in A$, we update the tree from the structure of the voronoi diagram. This sweep line is rather analogous to the sweep line performed for the "find intersecting lines" algorithm.



                Since construction of a voronoi diagram takes $O(n log n)$ time, the entire procedure is $O(n log n)$.






                share|cite|improve this answer











                $endgroup$



                Here's an $O(n log n)$ algorithm that works for all possible sets $A$ and $B$.



                Let $n = |A| + |B|$.



                This question has been asked in other platforms (here or here), but none of them give satisfactory answers (...at least to me. I cannot verify that they work in the claimed time for all possible inputs. For example, using KD tree does not guarantee $O(n log n)$ unless the points are sufficiently random. The answer to second link is even more evil).



                So, here's a purely $O(n log n)$ algorithm to solve this! Good thing you asked this in a math forum, because despite being theoretically interesting, I wouldn't want to implement it...



                First, construct the voronoi diagram $V_A$ of all the points in $A$. For each point $b_j in B$, find the voronoi cell $v_i in V_A$ that contains the point -- by the property of a voronoi diagram, we know that $a_i$ is the closest neighbor of $b_j$. Thus, by doing this for all points in $B$ and taking the minimum, we get the pair with minimum distance.



                Of course, that's assuming we are able to find the cell $v_i$ for each point $b_i$ quickly. To do it quickly, we use the sweep line algorithm: sweep all the points in the voronoi diagram $V_A$ and the points $B$. We store the current partition of the space using a binary tree so that whenever the sweep line encounters a point $b_i in B$, we are able to find the voronoi diagram containing $b_i$ in $O(log n)$. Whenever we encounter a point $a_i in A$, we update the tree from the structure of the voronoi diagram. This sweep line is rather analogous to the sweep line performed for the "find intersecting lines" algorithm.



                Since construction of a voronoi diagram takes $O(n log n)$ time, the entire procedure is $O(n log n)$.







                share|cite|improve this answer














                share|cite|improve this answer



                share|cite|improve this answer








                edited May 23 '17 at 12:39









                Community♦

                1




                1










                answered Dec 13 '14 at 9:40









                IrvanIrvan

                1,683822




                1,683822






























                    draft saved

                    draft discarded




















































                    Thanks for contributing an answer to Mathematics Stack Exchange!


                    • Please be sure to answer the question. Provide details and share your research!

                    But avoid …



                    • Asking for help, clarification, or responding to other answers.

                    • Making statements based on opinion; back them up with references or personal experience.


                    Use MathJax to format equations. MathJax reference.


                    To learn more, see our tips on writing great answers.




                    draft saved


                    draft discarded














                    StackExchange.ready(
                    function () {
                    StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fmath.stackexchange.com%2fquestions%2f610098%2fminimizing-the-distance-between-points-in-two-sets%23new-answer', 'question_page');
                    }
                    );

                    Post as a guest















                    Required, but never shown





















































                    Required, but never shown














                    Required, but never shown












                    Required, but never shown







                    Required, but never shown

































                    Required, but never shown














                    Required, but never shown












                    Required, but never shown







                    Required, but never shown







                    -

                    Popular posts from this blog

                    Måne

                    Image
                    För jordens måne, se Månen. Några månar i solsystemet i skala till vår måne En måne , naturlig satellit eller drabant är en himlakropp som kretsar kring en planet eller en asteroid i ett solsystem. Ordet i bestämd form – månen – avser planeten jordens måne. Det finns inte i något fall belagt att någon måne har egna månar. De flesta stora månar i solsystemet är bundna i synkron rotation med en och samma sida vänd mot planeten. Ett exempel på en måne som inte beter sig på detta vis, är Hyperion som kaotiskt roterar kring Saturnus. En asteroidmåne är en måne som kretsar kring en asteroid. En måne kan ha bildats samtidigt som moderplaneten eller senare infångats av planetens gravitationskraft. I vårt eget solsystem känner vi i nuläget till 173 månar runt sex av de åtta planeterna [ 1 ] : Jorden – månen Mars – Phobos och Deimos Jupiter – Ganymedes (som är solsystemets största måne), Io, Europa, Callisto och 59 andra kända månar Saturnus – Titan (den enda måne...
                    Read more

                    Storängen

                    Image
                    För stadsdelen i Mariehamn, se Storängen, Åland. För ett naturreservat i Norrtälje kommun, se Storängens naturreservat. Storängen från luften i september 1967, vy mot väst. Till vänster syns Järlasjön och Saltsjöbanans spår. Till höger löper Värmdövägen och längst ut till höger syns anläggningsarbetena för Värmdöleden. Storängen är ett villaområde i centrala Nacka i Stockholms län. Området är beläget strax sydost om Nacka Forum vid Saltsjöbanan mellan Lillängen och Saltsjö-Duvnäs. Storängens villasamhälle grundades 1904 av "Tjänstemännens Egnahemsförening vid Storängen" och de första villorna började byggas samma år. Redan 1909 var 107 tomter bebyggda av totalt runt 160. [ 1 ] År 2013 fanns drygt 150 villor med lika många familjer i området. Egnahemsföreningen existerar fortfarande och fungerar idag som intresseförening för de boende i Storängen. Storängen anses vara ett av Sveriges bäst bevarade villasamhällen från 1900-talets början, tack vare sina tidstypis...
                    Read more

                    VLT Carioca

                    Image
                    VLT Carioca Informações Proprietário Prefeitura do Rio de Janeiro Local [[Rio de Janeiro, RJ]] País {{country data Brasil| country flag2| name = Brasil| variant = | size = }} Tipo de transporte Bonde (Veículo leve sobre trilhos) Número de linhas 2 (+1 em construção) Número de estações 26 (+3 em construção) Tráfego 80 mil passageiros/dia [ 1 ] (dezembro/2018) Website www.vltrio.com.br Funcionamento Início de funcionamento 5 de junho de 2016 (2 anos) Operadora(s) Concessionária do VLT Carioca S.A. Número de veículos 32 Alstom Citadis Comprimento dos veículos 44 m (144 ft) Dados técnicos Extensão do sistema 28 km (17,4 mi) [ 2 ] Frequência 5–10 minutos Bitola Bitola padrão/internacional 1 435 mm (4,71 ft) Eletrificação APS, 750V DC Velocidade média 15 km/h (9,32 mph) [ 2 ] Velocidade máxima 50 km/h (31,1 mph) ...
                    Read more